// Machine generated IDispatch wrapper class(es) created with ClassWizard

#include "stdafx.h"
#include "pcdlrn.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

namespace pcdlrn
{

/////////////////////////////////////////////////////////////////////////////
// IFCFCommand properties

LPDISPATCH IFCFCommand::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x1, VT_DISPATCH, (void*)&result);
	return result;
}

void IFCFCommand::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x1, VT_DISPATCH, propVal);
}

LPDISPATCH IFCFCommand::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x2, VT_DISPATCH, (void*)&result);
	return result;
}

void IFCFCommand::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x2, VT_DISPATCH, propVal);
}

CString IFCFCommand::GetId()
{
	CString result;
	GetProperty(0x3, VT_BSTR, (void*)&result);
	return result;
}

void IFCFCommand::SetId(LPCTSTR propVal)
{
	SetProperty(0x3, VT_BSTR, propVal);
}

BOOL IFCFCommand::GetHasProfileDimension()
{
	BOOL result;
	GetProperty(0x4, VT_BOOL, (void*)&result);
	return result;
}

void IFCFCommand::SetHasProfileDimension(BOOL propVal)
{
	SetProperty(0x4, VT_BOOL, propVal);
}

LPDISPATCH IFCFCommand::GetProfileDimension()
{
	LPDISPATCH result;
	GetProperty(0x5, VT_DISPATCH, (void*)&result);
	return result;
}

void IFCFCommand::SetProfileDimension(LPDISPATCH propVal)
{
	SetProperty(0x5, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IFCFCommand operations


/////////////////////////////////////////////////////////////////////////////
// IApplication properties

LPDISPATCH IApplication::GetPartPrograms()
{
	LPDISPATCH result;
	GetProperty(0x1, VT_DISPATCH, (void*)&result);
	return result;
}

void IApplication::SetPartPrograms(LPDISPATCH propVal)
{
	SetProperty(0x1, VT_DISPATCH, propVal);
}

LPDISPATCH IApplication::GetActivePartProgram()
{
	LPDISPATCH result;
	GetProperty(0x2, VT_DISPATCH, (void*)&result);
	return result;
}

void IApplication::SetActivePartProgram(LPDISPATCH propVal)
{
	SetProperty(0x2, VT_DISPATCH, propVal);
}

CString IApplication::GetDefaultFilePath()
{
	CString result;
	GetProperty(0x3, VT_BSTR, (void*)&result);
	return result;
}

void IApplication::SetDefaultFilePath(LPCTSTR propVal)
{
	SetProperty(0x3, VT_BSTR, propVal);
}

CString IApplication::GetCaption()
{
	CString result;
	GetProperty(0x4, VT_BSTR, (void*)&result);
	return result;
}

void IApplication::SetCaption(LPCTSTR propVal)
{
	SetProperty(0x4, VT_BSTR, propVal);
}

CString IApplication::GetFullName()
{
	CString result;
	GetProperty(0x5, VT_BSTR, (void*)&result);
	return result;
}

void IApplication::SetFullName(LPCTSTR propVal)
{
	SetProperty(0x5, VT_BSTR, propVal);
}

CString IApplication::GetPath()
{
	CString result;
	GetProperty(0x6, VT_BSTR, (void*)&result);
	return result;
}

void IApplication::SetPath(LPCTSTR propVal)
{
	SetProperty(0x6, VT_BSTR, propVal);
}

CString IApplication::GetName()
{
	CString result;
	GetProperty(0x7, VT_BSTR, (void*)&result);
	return result;
}

void IApplication::SetName(LPCTSTR propVal)
{
	SetProperty(0x7, VT_BSTR, propVal);
}

BOOL IApplication::GetVisible()
{
	BOOL result;
	GetProperty(0x8, VT_BOOL, (void*)&result);
	return result;
}

void IApplication::SetVisible(BOOL propVal)
{
	SetProperty(0x8, VT_BOOL, propVal);
}

CString IApplication::GetStatusBar()
{
	CString result;
	GetProperty(0x9, VT_BSTR, (void*)&result);
	return result;
}

void IApplication::SetStatusBar(LPCTSTR propVal)
{
	SetProperty(0x9, VT_BSTR, propVal);
}

long IApplication::GetLeft()
{
	long result;
	GetProperty(0xa, VT_I4, (void*)&result);
	return result;
}

void IApplication::SetLeft(long propVal)
{
	SetProperty(0xa, VT_I4, propVal);
}

long IApplication::GetWidth()
{
	long result;
	GetProperty(0xb, VT_I4, (void*)&result);
	return result;
}

void IApplication::SetWidth(long propVal)
{
	SetProperty(0xb, VT_I4, propVal);
}

long IApplication::GetTop()
{
	long result;
	GetProperty(0xc, VT_I4, (void*)&result);
	return result;
}

void IApplication::SetTop(long propVal)
{
	SetProperty(0xc, VT_I4, propVal);
}

long IApplication::GetHeight()
{
	long result;
	GetProperty(0xd, VT_I4, (void*)&result);
	return result;
}

void IApplication::SetHeight(long propVal)
{
	SetProperty(0xd, VT_I4, propVal);
}

BOOL IApplication::GetOperatorMode()
{
	BOOL result;
	GetProperty(0xe, VT_BOOL, (void*)&result);
	return result;
}

void IApplication::SetOperatorMode(BOOL propVal)
{
	SetProperty(0xe, VT_BOOL, propVal);
}

BOOL IApplication::GetUserExit()
{
	BOOL result;
	GetProperty(0xf, VT_BOOL, (void*)&result);
	return result;
}

void IApplication::SetUserExit(BOOL propVal)
{
	SetProperty(0xf, VT_BOOL, propVal);
}

LPDISPATCH IApplication::GetMachines()
{
	LPDISPATCH result;
	GetProperty(0x10, VT_DISPATCH, (void*)&result);
	return result;
}

void IApplication::SetMachines(LPDISPATCH propVal)
{
	SetProperty(0x10, VT_DISPATCH, propVal);
}

CString IApplication::GetDefaultMachineName()
{
	CString result;
	GetProperty(0x11, VT_BSTR, (void*)&result);
	return result;
}

void IApplication::SetDefaultMachineName(LPCTSTR propVal)
{
	SetProperty(0x11, VT_BSTR, propVal);
}

CString IApplication::GetDefaultProbeFile()
{
	CString result;
	GetProperty(0x12, VT_BSTR, (void*)&result);
	return result;
}

void IApplication::SetDefaultProbeFile(LPCTSTR propVal)
{
	SetProperty(0x12, VT_BSTR, propVal);
}

LPDISPATCH IApplication::GetApplicationEvents()
{
	LPDISPATCH result;
	GetProperty(0x1b, VT_DISPATCH, (void*)&result);
	return result;
}

void IApplication::SetApplicationEvents(LPDISPATCH propVal)
{
	SetProperty(0x1b, VT_DISPATCH, propVal);
}

BOOL IApplication::GetRemotePanelMode()
{
	BOOL result;
	GetProperty(0x1c, VT_BOOL, (void*)&result);
	return result;
}

void IApplication::SetRemotePanelMode(BOOL propVal)
{
	SetProperty(0x1c, VT_BOOL, propVal);
}

long IApplication::GetMajorVersion()
{
	long result;
	GetProperty(0x1d, VT_I4, (void*)&result);
	return result;
}

void IApplication::SetMajorVersion(long propVal)
{
	SetProperty(0x1d, VT_I4, propVal);
}

long IApplication::GetMinorVersion()
{
	long result;
	GetProperty(0x1e, VT_I4, (void*)&result);
	return result;
}

void IApplication::SetMinorVersion(long propVal)
{
	SetProperty(0x1e, VT_I4, propVal);
}

CString IApplication::GetVersionString()
{
	CString result;
	GetProperty(0x1f, VT_BSTR, (void*)&result);
	return result;
}

void IApplication::SetVersionString(LPCTSTR propVal)
{
	SetProperty(0x1f, VT_BSTR, propVal);
}

long IApplication::GetErrorDialogEnabled()
{
	long result;
	GetProperty(0x21, VT_I4, (void*)&result);
	return result;
}

void IApplication::SetErrorDialogEnabled(long propVal)
{
	SetProperty(0x21, VT_I4, propVal);
}

BOOL IApplication::GetConnectedToSlave()
{
	BOOL result;
	GetProperty(0x22, VT_BOOL, (void*)&result);
	return result;
}

void IApplication::SetConnectedToSlave(BOOL propVal)
{
	SetProperty(0x22, VT_BOOL, propVal);
}

BOOL IApplication::GetConnectedToMaster()
{
	BOOL result;
	GetProperty(0x23, VT_BOOL, (void*)&result);
	return result;
}

void IApplication::SetConnectedToMaster(BOOL propVal)
{
	SetProperty(0x23, VT_BOOL, propVal);
}

BOOL IApplication::GetAdminPrivileges()
{
	BOOL result;
	GetProperty(0x38, VT_BOOL, (void*)&result);
	return result;
}

void IApplication::SetAdminPrivileges(BOOL propVal)
{
	SetProperty(0x38, VT_BOOL, propVal);
}

long IApplication::GetVerboseDialogs()
{
	long result;
	GetProperty(0x3b, VT_I4, (void*)&result);
	return result;
}

void IApplication::SetVerboseDialogs(long propVal)
{
	SetProperty(0x3b, VT_I4, propVal);
}

CString IApplication::GetCurrentUserDirectory()
{
	CString result;
	GetProperty(0x3d, VT_BSTR, (void*)&result);
	return result;
}

void IApplication::SetCurrentUserDirectory(LPCTSTR propVal)
{
	SetProperty(0x3d, VT_BSTR, propVal);
}

BOOL IApplication::GetConnectedInDriveMode()
{
	BOOL result;
	GetProperty(0x3e, VT_BOOL, (void*)&result);
	return result;
}

void IApplication::SetConnectedInDriveMode(BOOL propVal)
{
	SetProperty(0x3e, VT_BOOL, propVal);
}

BOOL IApplication::GetConnectedInRelayMode()
{
	BOOL result;
	GetProperty(0x3f, VT_BOOL, (void*)&result);
	return result;
}

void IApplication::SetConnectedInRelayMode(BOOL propVal)
{
	SetProperty(0x3f, VT_BOOL, propVal);
}

LPDISPATCH IApplication::GetApplicationSettings()
{
	LPDISPATCH result;
	GetProperty(0x40, VT_DISPATCH, (void*)&result);
	return result;
}

void IApplication::SetApplicationSettings(LPDISPATCH propVal)
{
	SetProperty(0x40, VT_DISPATCH, propVal);
}

long IApplication::GetLocaleID()
{
	long result;
	GetProperty(0x41, VT_I4, (void*)&result);
	return result;
}

void IApplication::SetLocaleID(long propVal)
{
	SetProperty(0x41, VT_I4, propVal);
}

LPDISPATCH IApplication::GetReportTemplates()
{
	LPDISPATCH result;
	GetProperty(0x43, VT_DISPATCH, (void*)&result);
	return result;
}

void IApplication::SetReportTemplates(LPDISPATCH propVal)
{
	SetProperty(0x43, VT_DISPATCH, propVal);
}

LPDISPATCH IApplication::GetLabelTemplates()
{
	LPDISPATCH result;
	GetProperty(0x44, VT_DISPATCH, (void*)&result);
	return result;
}

void IApplication::SetLabelTemplates(LPDISPATCH propVal)
{
	SetProperty(0x44, VT_DISPATCH, propVal);
}

CString IApplication::GetGetStringSetting()
{
	CString result;
	GetProperty(0x45, VT_BSTR, (void*)&result);
	return result;
}

void IApplication::SetGetStringSetting(LPCTSTR propVal)
{
	SetProperty(0x45, VT_BSTR, propVal);
}

double IApplication::GetGetDoubleSetting()
{
	double result;
	GetProperty(0x46, VT_R8, (void*)&result);
	return result;
}

void IApplication::SetGetDoubleSetting(double propVal)
{
	SetProperty(0x46, VT_R8, propVal);
}

long IApplication::GetGetIntSetting()
{
	long result;
	GetProperty(0x47, VT_I4, (void*)&result);
	return result;
}

void IApplication::SetGetIntSetting(long propVal)
{
	SetProperty(0x47, VT_I4, propVal);
}

long IApplication::GetGetDWORDSetting()
{
	long result;
	GetProperty(0x48, VT_I4, (void*)&result);
	return result;
}

void IApplication::SetGetDWORDSetting(long propVal)
{
	SetProperty(0x48, VT_I4, propVal);
}

BOOL IApplication::GetGetBoolSetting()
{
	BOOL result;
	GetProperty(0x49, VT_BOOL, (void*)&result);
	return result;
}

void IApplication::SetGetBoolSetting(BOOL propVal)
{
	SetProperty(0x49, VT_BOOL, propVal);
}

LPDISPATCH IApplication::GetPortLock()
{
	LPDISPATCH result;
	GetProperty(0x4c, VT_DISPATCH, (void*)&result);
	return result;
}

void IApplication::SetPortLock(LPDISPATCH propVal)
{
	SetProperty(0x4c, VT_DISPATCH, propVal);
}

long IApplication::GetReleaseType()
{
	long result;
	GetProperty(0x56, VT_I4, (void*)&result);
	return result;
}

void IApplication::SetReleaseType(long propVal)
{
	SetProperty(0x56, VT_I4, propVal);
}

CString IApplication::GetReleaseTypeName()
{
	CString result;
	GetProperty(0x57, VT_BSTR, (void*)&result);
	return result;
}

void IApplication::SetReleaseTypeName(LPCTSTR propVal)
{
	SetProperty(0x57, VT_BSTR, propVal);
}

LPDISPATCH IApplication::GetNotificationSettings()
{
	LPDISPATCH result;
	GetProperty(0x59, VT_DISPATCH, (void*)&result);
	return result;
}

void IApplication::SetNotificationSettings(LPDISPATCH propVal)
{
	SetProperty(0x59, VT_DISPATCH, propVal);
}

CString IApplication::Get_Name()
{
	CString result;
	GetProperty(0x0, VT_BSTR, (void*)&result);
	return result;
}

void IApplication::Set_Name(LPCTSTR propVal)
{
	SetProperty(0x0, VT_BSTR, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IApplication operations

void IApplication::Help(LPCTSTR HelpFile, long HelpContext, LPCTSTR HelpString)
{
	static BYTE parms[] =
		VTS_BSTR VTS_I4 VTS_BSTR;
	InvokeHelper(0x13, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 HelpFile, HelpContext, HelpString);
}

void IApplication::Restore()
{
	InvokeHelper(0x14, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IApplication::Minimize()
{
	InvokeHelper(0x15, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IApplication::Maximize()
{
	InvokeHelper(0x16, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL IApplication::SetActive()
{
	BOOL result;
	InvokeHelper(0x17, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
	return result;
}

BOOL IApplication::Post(LPCTSTR Source, LPCTSTR Destination)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR;
	InvokeHelper(0x18, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		Source, Destination);
	return result;
}

void IApplication::Quit()
{
	InvokeHelper(0x19, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IApplication::SpawnNewInstance()
{
	LPDISPATCH result;
	InvokeHelper(0x1a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

BOOL IApplication::WaitUntilReady(long TimeOutInSeconds)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x20, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		TimeOutInSeconds);
	return result;
}

BOOL IApplication::WriteRegistryString(LPCTSTR lpszSection, LPCTSTR lpszEntry, LPCTSTR lpszValue, BOOL bSetVariable)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR VTS_BSTR VTS_BOOL;
	InvokeHelper(0x24, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		lpszSection, lpszEntry, lpszValue, bSetVariable);
	return result;
}

CString IApplication::GetRegistryString(LPCTSTR lpszSection, LPCTSTR lpszEntry, LPCTSTR lpszDefault)
{
	CString result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR VTS_BSTR;
	InvokeHelper(0x25, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
		lpszSection, lpszEntry, lpszDefault);
	return result;
}

BOOL IApplication::WriteRegistryDouble(LPCTSTR lpszSection, LPCTSTR lpszEntry, double dValue, BOOL bSetVariable)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR VTS_R8 VTS_BOOL;
	InvokeHelper(0x26, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		lpszSection, lpszEntry, dValue, bSetVariable);
	return result;
}

double IApplication::GetRegistryDouble(LPCTSTR lpszSection, LPCTSTR lpszEntry, double dDefault)
{
	double result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR VTS_R8;
	InvokeHelper(0x27, DISPATCH_METHOD, VT_R8, (void*)&result, parms,
		lpszSection, lpszEntry, dDefault);
	return result;
}

BOOL IApplication::WriteRegistryInt(LPCTSTR lpszSection, LPCTSTR lpszEntry, long nValue, BOOL bSetVariable)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR VTS_I4 VTS_BOOL;
	InvokeHelper(0x28, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		lpszSection, lpszEntry, nValue, bSetVariable);
	return result;
}

long IApplication::GetRegistryInt(LPCTSTR lpszSection, LPCTSTR lpszEntry, long nDefault)
{
	long result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR VTS_I4;
	InvokeHelper(0x29, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		lpszSection, lpszEntry, nDefault);
	return result;
}

BOOL IApplication::WriteRegistryBool(LPCTSTR lpszSection, LPCTSTR lpszEntry, BOOL bValue, BOOL bSetVariable)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR VTS_BOOL VTS_BOOL;
	InvokeHelper(0x2a, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		lpszSection, lpszEntry, bValue, bSetVariable);
	return result;
}

BOOL IApplication::GetRegistryBool(LPCTSTR lpszSection, LPCTSTR lpszEntry, BOOL bDefault)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR VTS_BOOL;
	InvokeHelper(0x2b, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		lpszSection, lpszEntry, bDefault);
	return result;
}

BOOL IApplication::WriteRegistryDWORD(LPCTSTR lpszSection, LPCTSTR lpszEntry, long dwValue, BOOL bSetVariable)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR VTS_I4 VTS_BOOL;
	InvokeHelper(0x2c, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		lpszSection, lpszEntry, dwValue, bSetVariable);
	return result;
}

long IApplication::GetRegistryDWORD(LPCTSTR lpszSection, LPCTSTR lpszEntry, long dwDefault)
{
	long result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR VTS_I4;
	InvokeHelper(0x2d, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		lpszSection, lpszEntry, dwDefault);
	return result;
}

BOOL IApplication::WriteRegistryPoint(LPCTSTR lpszSection, LPCTSTR lpszEntry, double dX, double dY, double dZ, BOOL bSetVariable)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR VTS_R8 VTS_R8 VTS_R8 VTS_BOOL;
	InvokeHelper(0x2e, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		lpszSection, lpszEntry, dX, dY, dZ, bSetVariable);
	return result;
}

LPDISPATCH IApplication::GetRegistryPoint(LPCTSTR lpszSection, LPCTSTR lpszEntry, double dX, double dY, double dZ)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0x2f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		lpszSection, lpszEntry, dX, dY, dZ);
	return result;
}

BOOL IApplication::RegistryKeyExists(LPCTSTR lpszSection)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x30, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		lpszSection);
	return result;
}

BOOL IApplication::RegistryValueExists(LPCTSTR lpszSection, LPCTSTR lpszEntry)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR;
	InvokeHelper(0x31, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		lpszSection, lpszEntry);
	return result;
}

BOOL IApplication::DeleteRegistryValue(LPCTSTR lpszSection, LPCTSTR lpszEntry)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR;
	InvokeHelper(0x32, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		lpszSection, lpszEntry);
	return result;
}

BOOL IApplication::DeleteRegistryKey(LPCTSTR lpszSection)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x33, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		lpszSection);
	return result;
}

LPDISPATCH IApplication::GetRegistrySettings()
{
	LPDISPATCH result;
	InvokeHelper(0x34, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

void IApplication::_AddRegistrySetting(LPCTSTR szSection, LPCTSTR szEntry, LPCTSTR szDefault, long nType, long nFunction, BOOL bUserAdmin, BOOL bAutoEnabled, BOOL bSingleton)
{
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR VTS_BSTR VTS_I4 VTS_I4 VTS_BOOL VTS_BOOL VTS_BOOL;
	InvokeHelper(0x35, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 szSection, szEntry, szDefault, nType, nFunction, bUserAdmin, bAutoEnabled, bSingleton);
}

long IApplication::ExportRegistrySettings(LPCTSTR FilePath)
{
	long result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x36, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		FilePath);
	return result;
}

long IApplication::ImportRegistrySettings(LPCTSTR FilePath)
{
	long result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x37, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		FilePath);
	return result;
}

CString IApplication::GetHelpMap(long MenuId)
{
	CString result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x39, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
		MenuId);
	return result;
}

void IApplication::WriteRegistrySettings()
{
	InvokeHelper(0x3a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IApplication::WinHelp(long dwData, long nCmd)
{
	static BYTE parms[] =
		VTS_I4 VTS_I4;
	InvokeHelper(0x3c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 dwData, nCmd);
}

long IApplication::SwitchLanguageFiles(long fromLang, long toLang)
{
	long result;
	static BYTE parms[] =
		VTS_I4 VTS_I4;
	InvokeHelper(0x4d, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		fromLang, toLang);
	return result;
}

void IApplication::ChangeLanguage(long NewLanguage)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x4e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 NewLanguage);
}

BOOL IApplication::PartProgramMirror(LPCTSTR szPartProgramPathName, LPCTSTR szTargetProgramPathName, LPCTSTR szReferencePathName, long PartMirrorAxix, long ReporingMirrorOption, long MachineMirrorAxis)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR VTS_BSTR VTS_I4 VTS_I4 VTS_I4;
	InvokeHelper(0x4f, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		szPartProgramPathName, szTargetProgramPathName, szReferencePathName, PartMirrorAxix, ReporingMirrorOption, MachineMirrorAxis);
	return result;
}

CString IApplication::GetRegistryRoot()
{
	CString result;
	InvokeHelper(0x50, DISPATCH_METHOD, VT_BSTR, (void*)&result, NULL);
	return result;
}

CString IApplication::GetSystemHiddenFolder(BOOL bVersionSpecific)
{
	CString result;
	static BYTE parms[] =
		VTS_BOOL;
	InvokeHelper(0x51, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
		bVersionSpecific);
	return result;
}

CString IApplication::GetSystemDocuments(BOOL bVersionSpecific)
{
	CString result;
	static BYTE parms[] =
		VTS_BOOL;
	InvokeHelper(0x52, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
		bVersionSpecific);
	return result;
}

CString IApplication::GetUserHiddenFolder(BOOL bVersionSpecific)
{
	CString result;
	static BYTE parms[] =
		VTS_BOOL;
	InvokeHelper(0x53, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
		bVersionSpecific);
	return result;
}

CString IApplication::GetUserVisibleFolder(BOOL bVersionSpecific)
{
	CString result;
	static BYTE parms[] =
		VTS_BOOL;
	InvokeHelper(0x54, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
		bVersionSpecific);
	return result;
}

CString IApplication::GetSystemReportingFolder(BOOL bVersionSpecific)
{
	CString result;
	static BYTE parms[] =
		VTS_BOOL;
	InvokeHelper(0x55, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
		bVersionSpecific);
	return result;
}

BOOL IApplication::PartProgramMirror2(LPCTSTR szPartProgramPathName, LPCTSTR szTargetProgramPathName, LPCTSTR szReferencePathName, long PartMirrorAxix, long ReporingMirrorOption, long MachineMirrorAxis, BOOL DoNotMirrorCAD)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR VTS_BSTR VTS_I4 VTS_I4 VTS_I4 VTS_BOOL;
	InvokeHelper(0x58, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		szPartProgramPathName, szTargetProgramPathName, szReferencePathName, PartMirrorAxix, ReporingMirrorOption, MachineMirrorAxis, DoNotMirrorCAD);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IPartPrograms properties

long IPartPrograms::GetCount()
{
	long result;
	GetProperty(0x1, VT_I4, (void*)&result);
	return result;
}

void IPartPrograms::SetCount(long propVal)
{
	SetProperty(0x1, VT_I4, propVal);
}

LPDISPATCH IPartPrograms::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x2, VT_DISPATCH, (void*)&result);
	return result;
}

void IPartPrograms::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x2, VT_DISPATCH, propVal);
}

LPDISPATCH IPartPrograms::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x3, VT_DISPATCH, (void*)&result);
	return result;
}

void IPartPrograms::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x3, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IPartPrograms operations

LPDISPATCH IPartPrograms::Item(const VARIANT& NameorNum)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&NameorNum);
	return result;
}

void IPartPrograms::CloseAll()
{
	InvokeHelper(0x6, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL IPartPrograms::Remove(const VARIANT& NameorNum)
{
	BOOL result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		&NameorNum);
	return result;
}

LPDISPATCH IPartPrograms::Open(LPCTSTR filename, LPCTSTR MachineName)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR;
	InvokeHelper(0x8, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		filename, MachineName);
	return result;
}

LPDISPATCH IPartPrograms::Add(LPCTSTR Name, long Units, LPCTSTR Machine, LPCTSTR ProbeFile)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_BSTR VTS_I4 VTS_BSTR VTS_BSTR;
	InvokeHelper(0x9, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Name, Units, Machine, ProbeFile);
	return result;
}

LPDISPATCH IPartPrograms::_Item(const VARIANT& NameorNum)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&NameorNum);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IPartProgram properties

CString IPartProgram::GetPartName()
{
	CString result;
	GetProperty(0x1, VT_BSTR, (void*)&result);
	return result;
}

void IPartProgram::SetPartName(LPCTSTR propVal)
{
	SetProperty(0x1, VT_BSTR, propVal);
}

CString IPartProgram::GetPath()
{
	CString result;
	GetProperty(0x2, VT_BSTR, (void*)&result);
	return result;
}

void IPartProgram::SetPath(LPCTSTR propVal)
{
	SetProperty(0x2, VT_BSTR, propVal);
}

CString IPartProgram::GetRevisionNumber()
{
	CString result;
	GetProperty(0x3, VT_BSTR, (void*)&result);
	return result;
}

void IPartProgram::SetRevisionNumber(LPCTSTR propVal)
{
	SetProperty(0x3, VT_BSTR, propVal);
}

CString IPartProgram::GetSerialNumber()
{
	CString result;
	GetProperty(0x4, VT_BSTR, (void*)&result);
	return result;
}

void IPartProgram::SetSerialNumber(LPCTSTR propVal)
{
	SetProperty(0x4, VT_BSTR, propVal);
}

CString IPartProgram::GetFullName()
{
	CString result;
	GetProperty(0x5, VT_BSTR, (void*)&result);
	return result;
}

void IPartProgram::SetFullName(LPCTSTR propVal)
{
	SetProperty(0x5, VT_BSTR, propVal);
}

CString IPartProgram::GetName()
{
	CString result;
	GetProperty(0x6, VT_BSTR, (void*)&result);
	return result;
}

void IPartProgram::SetName(LPCTSTR propVal)
{
	SetProperty(0x6, VT_BSTR, propVal);
}

BOOL IPartProgram::GetVisible()
{
	BOOL result;
	GetProperty(0x7, VT_BOOL, (void*)&result);
	return result;
}

void IPartProgram::SetVisible(BOOL propVal)
{
	SetProperty(0x7, VT_BOOL, propVal);
}

LPDISPATCH IPartProgram::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x8, VT_DISPATCH, (void*)&result);
	return result;
}

void IPartProgram::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x8, VT_DISPATCH, propVal);
}

LPDISPATCH IPartProgram::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x9, VT_DISPATCH, (void*)&result);
	return result;
}

void IPartProgram::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x9, VT_DISPATCH, propVal);
}

LPDISPATCH IPartProgram::GetEditWindow()
{
	LPDISPATCH result;
	GetProperty(0xa, VT_DISPATCH, (void*)&result);
	return result;
}

void IPartProgram::SetEditWindow(LPDISPATCH propVal)
{
	SetProperty(0xa, VT_DISPATCH, propVal);
}

LPDISPATCH IPartProgram::GetCommands()
{
	LPDISPATCH result;
	GetProperty(0xb, VT_DISPATCH, (void*)&result);
	return result;
}

void IPartProgram::SetCommands(LPDISPATCH propVal)
{
	SetProperty(0xb, VT_DISPATCH, propVal);
}

LPDISPATCH IPartProgram::GetOldBasic()
{
	LPDISPATCH result;
	GetProperty(0xc, VT_DISPATCH, (void*)&result);
	return result;
}

void IPartProgram::SetOldBasic(LPDISPATCH propVal)
{
	SetProperty(0xc, VT_DISPATCH, propVal);
}

LPDISPATCH IPartProgram::GetCadWindows()
{
	LPDISPATCH result;
	GetProperty(0xd, VT_DISPATCH, (void*)&result);
	return result;
}

void IPartProgram::SetCadWindows(LPDISPATCH propVal)
{
	SetProperty(0xd, VT_DISPATCH, propVal);
}

LPDISPATCH IPartProgram::GetTools()
{
	LPDISPATCH result;
	GetProperty(0xe, VT_DISPATCH, (void*)&result);
	return result;
}

void IPartProgram::SetTools(LPDISPATCH propVal)
{
	SetProperty(0xe, VT_DISPATCH, propVal);
}

LPDISPATCH IPartProgram::GetProbes()
{
	LPDISPATCH result;
	GetProperty(0xf, VT_DISPATCH, (void*)&result);
	return result;
}

void IPartProgram::SetProbes(LPDISPATCH propVal)
{
	SetProperty(0xf, VT_DISPATCH, propVal);
}

LPDISPATCH IPartProgram::GetActiveMachine()
{
	LPDISPATCH result;
	GetProperty(0x10, VT_DISPATCH, (void*)&result);
	return result;
}

void IPartProgram::SetActiveMachine(LPDISPATCH propVal)
{
	SetProperty(0x10, VT_DISPATCH, propVal);
}

long IPartProgram::GetUnits()
{
	long result;
	GetProperty(0x1a, VT_I4, (void*)&result);
	return result;
}

void IPartProgram::SetUnits(long propVal)
{
	SetProperty(0x1a, VT_I4, propVal);
}

long IPartProgram::GetSpeed()
{
	long result;
	GetProperty(0x21, VT_I4, (void*)&result);
	return result;
}

void IPartProgram::SetSpeed(long propVal)
{
	SetProperty(0x21, VT_I4, propVal);
}

BOOL IPartProgram::GetExecuteDialogVisible()
{
	BOOL result;
	GetProperty(0x22, VT_BOOL, (void*)&result);
	return result;
}

void IPartProgram::SetExecuteDialogVisible(BOOL propVal)
{
	SetProperty(0x22, VT_BOOL, propVal);
}

LPDISPATCH IPartProgram::GetMasterSlaveDlg()
{
	LPDISPATCH result;
	GetProperty(0x23, VT_DISPATCH, (void*)&result);
	return result;
}

void IPartProgram::SetMasterSlaveDlg(LPDISPATCH propVal)
{
	SetProperty(0x23, VT_DISPATCH, propVal);
}

BOOL IPartProgram::GetConnectedToSlave()
{
	BOOL result;
	GetProperty(0x25, VT_BOOL, (void*)&result);
	return result;
}

void IPartProgram::SetConnectedToSlave(BOOL propVal)
{
	SetProperty(0x25, VT_BOOL, propVal);
}

BOOL IPartProgram::GetConnectedToMaster()
{
	BOOL result;
	GetProperty(0x26, VT_BOOL, (void*)&result);
	return result;
}

void IPartProgram::SetConnectedToMaster(BOOL propVal)
{
	SetProperty(0x26, VT_BOOL, propVal);
}

BOOL IPartProgram::GetExecutionWasCancelled()
{
	BOOL result;
	GetProperty(0x27, VT_BOOL, (void*)&result);
	return result;
}

void IPartProgram::SetExecutionWasCancelled(BOOL propVal)
{
	SetProperty(0x27, VT_BOOL, propVal);
}

LPDISPATCH IPartProgram::GetCadModel()
{
	LPDISPATCH result;
	GetProperty(0x28, VT_DISPATCH, (void*)&result);
	return result;
}

void IPartProgram::SetCadModel(LPDISPATCH propVal)
{
	SetProperty(0x28, VT_DISPATCH, propVal);
}

LPDISPATCH IPartProgram::GetPartProgramSettings()
{
	LPDISPATCH result;
	GetProperty(0x2b, VT_DISPATCH, (void*)&result);
	return result;
}

void IPartProgram::SetPartProgramSettings(LPDISPATCH propVal)
{
	SetProperty(0x2b, VT_DISPATCH, propVal);
}

BOOL IPartProgram::GetConnectedInDriveMode()
{
	BOOL result;
	GetProperty(0x2f, VT_BOOL, (void*)&result);
	return result;
}

void IPartProgram::SetConnectedInDriveMode(BOOL propVal)
{
	SetProperty(0x2f, VT_BOOL, propVal);
}

BOOL IPartProgram::GetConnectedInRelayMode()
{
	BOOL result;
	GetProperty(0x30, VT_BOOL, (void*)&result);
	return result;
}

void IPartProgram::SetConnectedInRelayMode(BOOL propVal)
{
	SetProperty(0x30, VT_BOOL, propVal);
}

LPDISPATCH IPartProgram::GetExecutedCommands()
{
	LPDISPATCH result;
	GetProperty(0x31, VT_DISPATCH, (void*)&result);
	return result;
}

void IPartProgram::SetExecutedCommands(LPDISPATCH propVal)
{
	SetProperty(0x31, VT_DISPATCH, propVal);
}

CString IPartProgram::GetEditWindowTextAll()
{
	CString result;
	GetProperty(0x32, VT_BSTR, (void*)&result);
	return result;
}

void IPartProgram::SetEditWindowTextAll(LPCTSTR propVal)
{
	SetProperty(0x32, VT_BSTR, propVal);
}

long IPartProgram::GetStatsCount()
{
	long result;
	GetProperty(0x35, VT_I4, (void*)&result);
	return result;
}

void IPartProgram::SetStatsCount(long propVal)
{
	SetProperty(0x35, VT_I4, propVal);
}

LPDISPATCH IPartProgram::GetReportWindow()
{
	LPDISPATCH result;
	GetProperty(0x38, VT_DISPATCH, (void*)&result);
	return result;
}

void IPartProgram::SetReportWindow(LPDISPATCH propVal)
{
	SetProperty(0x38, VT_DISPATCH, propVal);
}

long IPartProgram::GetCurrentArm()
{
	long result;
	GetProperty(0x3a, VT_I4, (void*)&result);
	return result;
}

void IPartProgram::SetCurrentArm(long propVal)
{
	SetProperty(0x3a, VT_I4, propVal);
}

BOOL IPartProgram::GetNoActiveProbesObject()
{
	BOOL result;
	GetProperty(0x3f, VT_BOOL, (void*)&result);
	return result;
}

void IPartProgram::SetNoActiveProbesObject(BOOL propVal)
{
	SetProperty(0x3f, VT_BOOL, propVal);
}

CString IPartProgram::GetCurrentProbeName()
{
	CString result;
	GetProperty(0x40, VT_BSTR, (void*)&result);
	return result;
}

void IPartProgram::SetCurrentProbeName(LPCTSTR propVal)
{
	SetProperty(0x40, VT_BSTR, propVal);
}

BOOL IPartProgram::GetShowAllIDs()
{
	BOOL result;
	GetProperty(0x41, VT_BOOL, (void*)&result);
	return result;
}

void IPartProgram::SetShowAllIDs(BOOL propVal)
{
	SetProperty(0x41, VT_BOOL, propVal);
}

LPDISPATCH IPartProgram::GetQuickStart()
{
	LPDISPATCH result;
	GetProperty(0x43, VT_DISPATCH, (void*)&result);
	return result;
}

void IPartProgram::SetQuickStart(LPDISPATCH propVal)
{
	SetProperty(0x43, VT_DISPATCH, propVal);
}

BOOL IPartProgram::GetReadoutEnabled()
{
	BOOL result;
	GetProperty(0x4b, VT_BOOL, (void*)&result);
	return result;
}

void IPartProgram::SetReadoutEnabled(BOOL propVal)
{
	SetProperty(0x4b, VT_BOOL, propVal);
}

LPDISPATCH IPartProgram::GetBundledStations()
{
	LPDISPATCH result;
	GetProperty(0x4c, VT_DISPATCH, (void*)&result);
	return result;
}

void IPartProgram::SetBundledStations(LPDISPATCH propVal)
{
	SetProperty(0x4c, VT_DISPATCH, propVal);
}

CString IPartProgram::GetOutputFileName()
{
	CString result;
	GetProperty(0x56, VT_BSTR, (void*)&result);
	return result;
}

void IPartProgram::SetOutputFileName(LPCTSTR propVal)
{
	SetProperty(0x56, VT_BSTR, propVal);
}

BOOL IPartProgram::GetExecOptStopButtonVisible()
{
	BOOL result;
	GetProperty(0x58, VT_BOOL, (void*)&result);
	return result;
}

void IPartProgram::SetExecOptStopButtonVisible(BOOL propVal)
{
	SetProperty(0x58, VT_BOOL, propVal);
}

BOOL IPartProgram::GetExecOptSkipButtonVisible()
{
	BOOL result;
	GetProperty(0x59, VT_BOOL, (void*)&result);
	return result;
}

void IPartProgram::SetExecOptSkipButtonVisible(BOOL propVal)
{
	SetProperty(0x59, VT_BOOL, propVal);
}

BOOL IPartProgram::GetExecOptContinueButtonVisible()
{
	BOOL result;
	GetProperty(0x5a, VT_BOOL, (void*)&result);
	return result;
}

void IPartProgram::SetExecOptContinueButtonVisible(BOOL propVal)
{
	SetProperty(0x5a, VT_BOOL, propVal);
}

BOOL IPartProgram::GetExecOptJumpButtonVisible()
{
	BOOL result;
	GetProperty(0x5b, VT_BOOL, (void*)&result);
	return result;
}

void IPartProgram::SetExecOptJumpButtonVisible(BOOL propVal)
{
	SetProperty(0x5b, VT_BOOL, propVal);
}

BOOL IPartProgram::GetMarkChildMode()
{
	BOOL result;
	GetProperty(0x5c, VT_BOOL, (void*)&result);
	return result;
}

void IPartProgram::SetMarkChildMode(BOOL propVal)
{
	SetProperty(0x5c, VT_BOOL, propVal);
}

BOOL IPartProgram::GetMarkParentMode()
{
	BOOL result;
	GetProperty(0x5d, VT_BOOL, (void*)&result);
	return result;
}

void IPartProgram::SetMarkParentMode(BOOL propVal)
{
	SetProperty(0x5d, VT_BOOL, propVal);
}

long IPartProgram::GetMarkNewAlignmentMode()
{
	long result;
	GetProperty(0x5e, VT_I4, (void*)&result);
	return result;
}

void IPartProgram::SetMarkNewAlignmentMode(long propVal)
{
	SetProperty(0x5e, VT_I4, propVal);
}

long IPartProgram::GetProgramVersionSchema()
{
	long result;
	GetProperty(0x61, VT_I4, (void*)&result);
	return result;
}

void IPartProgram::SetProgramVersionSchema(long propVal)
{
	SetProperty(0x61, VT_I4, propVal);
}

CString IPartProgram::GetProgramVersionName()
{
	CString result;
	GetProperty(0x62, VT_BSTR, (void*)&result);
	return result;
}

void IPartProgram::SetProgramVersionName(LPCTSTR propVal)
{
	SetProperty(0x62, VT_BSTR, propVal);
}

CString IPartProgram::Get_Name()
{
	CString result;
	GetProperty(0x0, VT_BSTR, (void*)&result);
	return result;
}

void IPartProgram::Set_Name(LPCTSTR propVal)
{
	SetProperty(0x0, VT_BSTR, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IPartProgram operations

void IPartProgram::Close()
{
	InvokeHelper(0x11, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL IPartProgram::Export(LPCTSTR Name)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x12, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		Name);
	return result;
}

BOOL IPartProgram::Import(LPCTSTR Name)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x13, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		Name);
	return result;
}

BOOL IPartProgram::Quit()
{
	BOOL result;
	InvokeHelper(0x14, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
	return result;
}

BOOL IPartProgram::Save()
{
	BOOL result;
	InvokeHelper(0x15, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
	return result;
}

BOOL IPartProgram::SaveAs(LPCTSTR Name)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x16, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		Name);
	return result;
}

void IPartProgram::Activate()
{
	InvokeHelper(0x17, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL IPartProgram::EXECUTE()
{
	BOOL result;
	InvokeHelper(0x18, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
	return result;
}

long IPartProgram::MessageBox(LPCTSTR Message, LPCTSTR TITLE, long Type)
{
	long result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR VTS_I4;
	InvokeHelper(0x19, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		Message, TITLE, Type);
	return result;
}

BOOL IPartProgram::AsyncExecute()
{
	BOOL result;
	InvokeHelper(0x1b, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
	return result;
}

LPDISPATCH IPartProgram::GetVariableValue(LPCTSTR VarName)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x1c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		VarName);
	return result;
}

BOOL IPartProgram::SetVariableValue(LPCTSTR VarName, LPDISPATCH Value)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR VTS_DISPATCH;
	InvokeHelper(0x1d, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		VarName, Value);
	return result;
}

BOOL IPartProgram::DmisOut(long bExecOrder, LPCTSTR filename)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4 VTS_BSTR;
	InvokeHelper(0x1e, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		bExecOrder, filename);
	return result;
}

void IPartProgram::RefreshPart()
{
	InvokeHelper(0x1f, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

long IPartProgram::OverrideExecuteSpeed(long NewSpeed)
{
	long result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x20, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		NewSpeed);
	return result;
}

void IPartProgram::ToggleMasterSlaveMode()
{
	InvokeHelper(0x24, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL IPartProgram::LoadLayout(LPCTSTR LayoutFileName)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x29, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		LayoutFileName);
	return result;
}

BOOL IPartProgram::IsProbeAnalog(long ArmNumber)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x2a, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		ArmNumber);
	return result;
}

BOOL IPartProgram::SetExecutionBlock(LPDISPATCH StartCommand, LPDISPATCH EndCommand)
{
	BOOL result;
	static BYTE parms[] =
		VTS_DISPATCH VTS_DISPATCH;
	InvokeHelper(0x2c, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		StartCommand, EndCommand);
	return result;
}

void IPartProgram::ClearExecutionBlock()
{
	InvokeHelper(0x2d, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL IPartProgram::RunJournalFile(LPCTSTR lpszJFileName)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x2e, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		lpszJFileName);
	return result;
}

BOOL IPartProgram::WaitUntilExecuted(LPDISPATCH Command, long timeout, long Arm)
{
	BOOL result;
	static BYTE parms[] =
		VTS_DISPATCH VTS_I4 VTS_I4;
	InvokeHelper(0x33, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		Command, timeout, Arm);
	return result;
}

void IPartProgram::EditRulesFile(LPCTSTR filename)
{
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x34, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 filename);
}

BOOL IPartProgram::ClearTADs()
{
	BOOL result;
	InvokeHelper(0x36, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
	return result;
}

BOOL IPartProgram::ClearAllTADs()
{
	BOOL result;
	InvokeHelper(0x37, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
	return result;
}

BOOL IPartProgram::DmisOut2(long bExecOrder, LPCTSTR filename, long bOutputLastInstanceOnly)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4 VTS_BSTR VTS_I4;
	InvokeHelper(0x39, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		bExecOrder, filename, bOutputLastInstanceOnly);
	return result;
}

BOOL IPartProgram::AutoCreateGroupsForBMWMessPrograms(long bUseDimensionName)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x3b, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		bUseDimensionName);
	return result;
}

BOOL IPartProgram::SetVerifyFeaturesFlag()
{
	BOOL result;
	InvokeHelper(0x3c, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
	return result;
}

BOOL IPartProgram::ClearVerifyFeaturesFlag()
{
	BOOL result;
	InvokeHelper(0x3d, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
	return result;
}

BOOL IPartProgram::IgnoreLearnModeHits(long bState)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x3e, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		bState);
	return result;
}

BOOL IPartProgram::ImportUGDCI(LPCTSTR Name)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x42, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		Name);
	return result;
}

void IPartProgram::ExternalCommandEvent(long CommandId, long EventId)
{
	static BYTE parms[] =
		VTS_I4 VTS_I4;
	InvokeHelper(0x44, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 CommandId, EventId);
}

LPDISPATCH IPartProgram::CalcAdjustTransform(LPCTSTR Part1AlignID, LPCTSTR Part2AlignID)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR;
	InvokeHelper(0x45, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Part1AlignID, Part2AlignID);
	return result;
}

LPDISPATCH IPartProgram::Guess(long featType, long addFeat)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4 VTS_I4;
	InvokeHelper(0x46, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		featType, addFeat);
	return result;
}

BOOL IPartProgram::RemoveLastLearnHit()
{
	BOOL result;
	InvokeHelper(0x47, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
	return result;
}

LPDISPATCH IPartProgram::CreateGuessWithDimension(long featType, long addFeat, LPCTSTR dimID, double nom1, double nom2, double Plus, double Minus, double form, long mmUnits, long includeLocation, LPDISPATCH refCmd)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_BSTR VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_I4 VTS_I4 VTS_DISPATCH;
	InvokeHelper(0x48, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		featType, addFeat, dimID, nom1, nom2, Plus, Minus, form, mmUnits, includeLocation, refCmd);
	return result;
}

LPDISPATCH IPartProgram::GetExecutionWindow(long Arm)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x49, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Arm);
	return result;
}

void IPartProgram::SetIPPlanVersion(LPCTSTR UID, long version)
{
	static BYTE parms[] =
		VTS_BSTR VTS_I4;
	InvokeHelper(0x4a, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 UID, version);
}

BOOL IPartProgram::SetExecutionMarkedSet(const VARIANT& NameorNum)
{
	BOOL result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x4d, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		&NameorNum);
	return result;
}

void IPartProgram::ClearExecutionMarkedSet()
{
	InvokeHelper(0x4e, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

long IPartProgram::GetExecutionMarkedSetIndex()
{
	long result;
	InvokeHelper(0x4f, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
	return result;
}

long IPartProgram::GetMarkedSetName(long index, BSTR* markedSetName)
{
	long result;
	static BYTE parms[] =
		VTS_I4 VTS_PBSTR;
	InvokeHelper(0x50, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		index, markedSetName);
	return result;
}

long IPartProgram::GetMarkedSetNumbers(long* mazAllowedMarkedSets, long* markedSetCount)
{
	long result;
	static BYTE parms[] =
		VTS_PI4 VTS_PI4;
	InvokeHelper(0x51, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		mazAllowedMarkedSets, markedSetCount);
	return result;
}

LPDISPATCH IPartProgram::GetReadoutWindow(long Arm)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x52, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Arm);
	return result;
}

void IPartProgram::ExportToXML(LPCTSTR filename)
{
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x53, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 filename);
}

void IPartProgram::ImportXML(LPCTSTR filename)
{
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x54, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 filename);
}

void IPartProgram::SetupFeatureBasedMeasurement(LPCTSTR filename)
{
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x55, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 filename);
}

BOOL IPartProgram::SaveAs2(LPCTSTR Name, BOOL CadAsReference)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR VTS_BOOL;
	InvokeHelper(0x57, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		Name, CadAsReference);
	return result;
}

VARIANT IPartProgram::GetAvailableSchemasForSaveAs(BOOL bSchemaNumbers)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_BOOL;
	InvokeHelper(0x5f, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		bSchemaNumbers);
	return result;
}

BOOL IPartProgram::SaveAs3(LPCTSTR Name, const VARIANT& NameOrSchema, BOOL CadAsReference)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR VTS_VARIANT VTS_BOOL;
	InvokeHelper(0x60, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		Name, &NameOrSchema, CadAsReference);
	return result;
}

void IPartProgram::ExecuteMiniRoutineByName(LPCTSTR Name, BOOL AlignmentDependencies)
{
	static BYTE parms[] =
		VTS_BSTR VTS_BOOL;
	InvokeHelper(0x63, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Name, AlignmentDependencies);
}

void IPartProgram::ExecuteMiniRoutineByUID(LPCTSTR UID, BOOL AlignmentDependencies)
{
	static BYTE parms[] =
		VTS_BSTR VTS_BOOL;
	InvokeHelper(0x64, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 UID, AlignmentDependencies);
}

void IPartProgram::CopyAutoFeatureInspectionPlannerSettingsIntoRegistryDefaultSettings()
{
	InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IPartProgram::SetCadEqualPart(LPCTSTR AlignID)
{
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x66, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 AlignID);
}


/////////////////////////////////////////////////////////////////////////////
// IEditWindow properties

LPDISPATCH IEditWindow::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x1, VT_DISPATCH, (void*)&result);
	return result;
}

void IEditWindow::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x1, VT_DISPATCH, propVal);
}

BOOL IEditWindow::GetVisible()
{
	BOOL result;
	GetProperty(0x2, VT_BOOL, (void*)&result);
	return result;
}

void IEditWindow::SetVisible(BOOL propVal)
{
	SetProperty(0x2, VT_BOOL, propVal);
}

long IEditWindow::GetLeft()
{
	long result;
	GetProperty(0x4, VT_I4, (void*)&result);
	return result;
}

void IEditWindow::SetLeft(long propVal)
{
	SetProperty(0x4, VT_I4, propVal);
}

long IEditWindow::GetWidth()
{
	long result;
	GetProperty(0x5, VT_I4, (void*)&result);
	return result;
}

void IEditWindow::SetWidth(long propVal)
{
	SetProperty(0x5, VT_I4, propVal);
}

long IEditWindow::GetTop()
{
	long result;
	GetProperty(0x6, VT_I4, (void*)&result);
	return result;
}

void IEditWindow::SetTop(long propVal)
{
	SetProperty(0x6, VT_I4, propVal);
}

long IEditWindow::GetHeight()
{
	long result;
	GetProperty(0x7, VT_I4, (void*)&result);
	return result;
}

void IEditWindow::SetHeight(long propVal)
{
	SetProperty(0x7, VT_I4, propVal);
}

BOOL IEditWindow::GetShowFeatures()
{
	BOOL result;
	GetProperty(0x8, VT_BOOL, (void*)&result);
	return result;
}

void IEditWindow::SetShowFeatures(BOOL propVal)
{
	SetProperty(0x8, VT_BOOL, propVal);
}

BOOL IEditWindow::GetShowAlignments()
{
	BOOL result;
	GetProperty(0x9, VT_BOOL, (void*)&result);
	return result;
}

void IEditWindow::SetShowAlignments(BOOL propVal)
{
	SetProperty(0x9, VT_BOOL, propVal);
}

BOOL IEditWindow::GetShowMoves()
{
	BOOL result;
	GetProperty(0xa, VT_BOOL, (void*)&result);
	return result;
}

void IEditWindow::SetShowMoves(BOOL propVal)
{
	SetProperty(0xa, VT_BOOL, propVal);
}

BOOL IEditWindow::GetShowComments()
{
	BOOL result;
	GetProperty(0xb, VT_BOOL, (void*)&result);
	return result;
}

void IEditWindow::SetShowComments(BOOL propVal)
{
	SetProperty(0xb, VT_BOOL, propVal);
}

BOOL IEditWindow::GetShowDimensions()
{
	BOOL result;
	GetProperty(0xc, VT_BOOL, (void*)&result);
	return result;
}

void IEditWindow::SetShowDimensions(BOOL propVal)
{
	SetProperty(0xc, VT_BOOL, propVal);
}

BOOL IEditWindow::GetShowHits()
{
	BOOL result;
	GetProperty(0xd, VT_BOOL, (void*)&result);
	return result;
}

void IEditWindow::SetShowHits(BOOL propVal)
{
	SetProperty(0xd, VT_BOOL, propVal);
}

BOOL IEditWindow::GetShowOutTolOnly()
{
	BOOL result;
	GetProperty(0xe, VT_BOOL, (void*)&result);
	return result;
}

void IEditWindow::SetShowOutTolOnly(BOOL propVal)
{
	SetProperty(0xe, VT_BOOL, propVal);
}

BOOL IEditWindow::GetShowTips()
{
	BOOL result;
	GetProperty(0xf, VT_BOOL, (void*)&result);
	return result;
}

void IEditWindow::SetShowTips(BOOL propVal)
{
	SetProperty(0xf, VT_BOOL, propVal);
}

BOOL IEditWindow::GetShowHeaderFooter()
{
	BOOL result;
	GetProperty(0x10, VT_BOOL, (void*)&result);
	return result;
}

void IEditWindow::SetShowHeaderFooter(BOOL propVal)
{
	SetProperty(0x10, VT_BOOL, propVal);
}

LPDISPATCH IEditWindow::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x11, VT_DISPATCH, (void*)&result);
	return result;
}

void IEditWindow::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x11, VT_DISPATCH, propVal);
}

BOOL IEditWindow::Get_Visible()
{
	BOOL result;
	GetProperty(0x0, VT_BOOL, (void*)&result);
	return result;
}

void IEditWindow::Set_Visible(BOOL propVal)
{
	SetProperty(0x0, VT_BOOL, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IEditWindow operations

void IEditWindow::CommandMode()
{
	InvokeHelper(0x12, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEditWindow::ReportMode()
{
	InvokeHelper(0x13, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEditWindow::SetPrintOptions(long Location, long Draft, long Filemode, long ExtNum)
{
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_I4 VTS_I4;
	InvokeHelper(0x14, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Location, Draft, Filemode, ExtNum);
}

void IEditWindow::PrintEditWindow()
{
	InvokeHelper(0x15, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEditWindow::SetPrintOptionsEx(long Location, long Draft, long Filemode, long ExtNum, LPCTSTR filename, long format, BOOL bHyperReportsInline)
{
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_BSTR VTS_I4 VTS_BOOL;
	InvokeHelper(0x16, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Location, Draft, Filemode, ExtNum, filename, format, bHyperReportsInline);
}

void IEditWindow::SetDMISOutputOptions(BOOL bEnable, LPCTSTR filename, long bOverwrite, long bOutputTheos, BOOL bOutputFeatWithDimensions)
{
	static BYTE parms[] =
		VTS_BOOL VTS_BSTR VTS_I4 VTS_I4 VTS_BOOL;
	InvokeHelper(0x17, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 bEnable, filename, bOverwrite, bOutputTheos, bOutputFeatWithDimensions);
}

void IEditWindow::LastExecutionReportMode()
{
	InvokeHelper(0x18, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEditWindow::DMISMode()
{
	InvokeHelper(0x19, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

CString IEditWindow::GetCommandText(LPDISPATCH Command)
{
	CString result;
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x1a, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
		Command);
	return result;
}

void IEditWindow::SummaryMode()
{
	InvokeHelper(0x1b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEditWindow::SelectCommand()
{
	InvokeHelper(0x1d, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEditWindow::CopySelectedToClipboard()
{
	InvokeHelper(0x1e, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEditWindow::PasteFromClipboard()
{
	InvokeHelper(0x1f, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

long IEditWindow::SetPasteWithPatternMirror(long Type)
{
	long result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x20, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		Type);
	return result;
}

void IEditWindow::PasteFromClipboardWithPattern()
{
	InvokeHelper(0x21, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// ICommand properties

CString ICommand::Get_id()
{
	CString result;
	GetProperty(0x0, VT_BSTR, (void*)&result);
	return result;
}

void ICommand::Set_id(LPCTSTR propVal)
{
	SetProperty(0x0, VT_BSTR, propVal);
}

long ICommand::GetCount()
{
	long result;
	GetProperty(0x1, VT_I4, (void*)&result);
	return result;
}

void ICommand::SetCount(long propVal)
{
	SetProperty(0x1, VT_I4, propVal);
}

long ICommand::GetFeature()
{
	long result;
	GetProperty(0x2, VT_I4, (void*)&result);
	return result;
}

void ICommand::SetFeature(long propVal)
{
	SetProperty(0x2, VT_I4, propVal);
}

CString ICommand::GetId()
{
	CString result;
	GetProperty(0x3, VT_BSTR, (void*)&result);
	return result;
}

void ICommand::SetId(LPCTSTR propVal)
{
	SetProperty(0x3, VT_BSTR, propVal);
}

LPDISPATCH ICommand::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x4, VT_DISPATCH, (void*)&result);
	return result;
}

void ICommand::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x4, VT_DISPATCH, propVal);
}

LPDISPATCH ICommand::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x5, VT_DISPATCH, (void*)&result);
	return result;
}

void ICommand::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x5, VT_DISPATCH, propVal);
}

long ICommand::GetType()
{
	long result;
	GetProperty(0x6, VT_I4, (void*)&result);
	return result;
}

void ICommand::SetType(long propVal)
{
	SetProperty(0x6, VT_I4, propVal);
}

LPDISPATCH ICommand::GetAlignmentCommand()
{
	LPDISPATCH result;
	GetProperty(0x7, VT_DISPATCH, (void*)&result);
	return result;
}

void ICommand::SetAlignmentCommand(LPDISPATCH propVal)
{
	SetProperty(0x7, VT_DISPATCH, propVal);
}

LPDISPATCH ICommand::GetDimensionCommand()
{
	LPDISPATCH result;
	GetProperty(0x8, VT_DISPATCH, (void*)&result);
	return result;
}

void ICommand::SetDimensionCommand(LPDISPATCH propVal)
{
	SetProperty(0x8, VT_DISPATCH, propVal);
}

LPDISPATCH ICommand::GetFeatureCommand()
{
	LPDISPATCH result;
	GetProperty(0x9, VT_DISPATCH, (void*)&result);
	return result;
}

void ICommand::SetFeatureCommand(LPDISPATCH propVal)
{
	SetProperty(0x9, VT_DISPATCH, propVal);
}

LPDISPATCH ICommand::GetModalCommand()
{
	LPDISPATCH result;
	GetProperty(0xa, VT_DISPATCH, (void*)&result);
	return result;
}

void ICommand::SetModalCommand(LPDISPATCH propVal)
{
	SetProperty(0xa, VT_DISPATCH, propVal);
}

LPDISPATCH ICommand::GetMoveCommand()
{
	LPDISPATCH result;
	GetProperty(0xb, VT_DISPATCH, (void*)&result);
	return result;
}

void ICommand::SetMoveCommand(LPDISPATCH propVal)
{
	SetProperty(0xb, VT_DISPATCH, propVal);
}

LPDISPATCH ICommand::GetFlowControlCommand()
{
	LPDISPATCH result;
	GetProperty(0xc, VT_DISPATCH, (void*)&result);
	return result;
}

void ICommand::SetFlowControlCommand(LPDISPATCH propVal)
{
	SetProperty(0xc, VT_DISPATCH, propVal);
}

LPDISPATCH ICommand::GetBasicScanCommand()
{
	LPDISPATCH result;
	GetProperty(0xd, VT_DISPATCH, (void*)&result);
	return result;
}

void ICommand::SetBasicScanCommand(LPDISPATCH propVal)
{
	SetProperty(0xd, VT_DISPATCH, propVal);
}

BOOL ICommand::GetIsAlignment()
{
	BOOL result;
	GetProperty(0xe, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetIsAlignment(BOOL propVal)
{
	SetProperty(0xe, VT_BOOL, propVal);
}

BOOL ICommand::GetIsFeature()
{
	BOOL result;
	GetProperty(0xf, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetIsFeature(BOOL propVal)
{
	SetProperty(0xf, VT_BOOL, propVal);
}

BOOL ICommand::GetIsBasicScan()
{
	BOOL result;
	GetProperty(0x10, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetIsBasicScan(BOOL propVal)
{
	SetProperty(0x10, VT_BOOL, propVal);
}

BOOL ICommand::GetIsDimension()
{
	BOOL result;
	GetProperty(0x11, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetIsDimension(BOOL propVal)
{
	SetProperty(0x11, VT_BOOL, propVal);
}

BOOL ICommand::GetIsFlowControl()
{
	BOOL result;
	GetProperty(0x12, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetIsFlowControl(BOOL propVal)
{
	SetProperty(0x12, VT_BOOL, propVal);
}

BOOL ICommand::GetIsModal()
{
	BOOL result;
	GetProperty(0x13, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetIsModal(BOOL propVal)
{
	SetProperty(0x13, VT_BOOL, propVal);
}

BOOL ICommand::GetIsMove()
{
	BOOL result;
	GetProperty(0x14, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetIsMove(BOOL propVal)
{
	SetProperty(0x14, VT_BOOL, propVal);
}

BOOL ICommand::GetMarked()
{
	BOOL result;
	GetProperty(0x15, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetMarked(BOOL propVal)
{
	SetProperty(0x15, VT_BOOL, propVal);
}

LPDISPATCH ICommand::GetCalibrationCommand()
{
	LPDISPATCH result;
	GetProperty(0x21, VT_DISPATCH, (void*)&result);
	return result;
}

void ICommand::SetCalibrationCommand(LPDISPATCH propVal)
{
	SetProperty(0x21, VT_DISPATCH, propVal);
}

BOOL ICommand::GetIsCalibration()
{
	BOOL result;
	GetProperty(0x22, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetIsCalibration(BOOL propVal)
{
	SetProperty(0x22, VT_BOOL, propVal);
}

LPDISPATCH ICommand::GetAttachCommand()
{
	LPDISPATCH result;
	GetProperty(0x23, VT_DISPATCH, (void*)&result);
	return result;
}

void ICommand::SetAttachCommand(LPDISPATCH propVal)
{
	SetProperty(0x23, VT_DISPATCH, propVal);
}

BOOL ICommand::GetIsAttach()
{
	BOOL result;
	GetProperty(0x24, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetIsAttach(BOOL propVal)
{
	SetProperty(0x24, VT_BOOL, propVal);
}

LPDISPATCH ICommand::GetExternalCommand()
{
	LPDISPATCH result;
	GetProperty(0x25, VT_DISPATCH, (void*)&result);
	return result;
}

void ICommand::SetExternalCommand(LPDISPATCH propVal)
{
	SetProperty(0x25, VT_DISPATCH, propVal);
}

BOOL ICommand::GetIsExternalCommand()
{
	BOOL result;
	GetProperty(0x26, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetIsExternalCommand(BOOL propVal)
{
	SetProperty(0x26, VT_BOOL, propVal);
}

LPDISPATCH ICommand::GetOptionProbeCommand()
{
	LPDISPATCH result;
	GetProperty(0x27, VT_DISPATCH, (void*)&result);
	return result;
}

void ICommand::SetOptionProbeCommand(LPDISPATCH propVal)
{
	SetProperty(0x27, VT_DISPATCH, propVal);
}

BOOL ICommand::GetIsOptionProbe()
{
	BOOL result;
	GetProperty(0x28, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetIsOptionProbe(BOOL propVal)
{
	SetProperty(0x28, VT_BOOL, propVal);
}

LPDISPATCH ICommand::GetLeapfrogCommand()
{
	LPDISPATCH result;
	GetProperty(0x29, VT_DISPATCH, (void*)&result);
	return result;
}

void ICommand::SetLeapfrogCommand(LPDISPATCH propVal)
{
	SetProperty(0x29, VT_DISPATCH, propVal);
}

BOOL ICommand::GetIsLeapfrog()
{
	BOOL result;
	GetProperty(0x2a, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetIsLeapfrog(BOOL propVal)
{
	SetProperty(0x2a, VT_BOOL, propVal);
}

LPDISPATCH ICommand::GetOptMotionCommand()
{
	LPDISPATCH result;
	GetProperty(0x2b, VT_DISPATCH, (void*)&result);
	return result;
}

void ICommand::SetOptMotionCommand(LPDISPATCH propVal)
{
	SetProperty(0x2b, VT_DISPATCH, propVal);
}

BOOL ICommand::GetIsOptMotion()
{
	BOOL result;
	GetProperty(0x2c, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetIsOptMotion(BOOL propVal)
{
	SetProperty(0x2c, VT_BOOL, propVal);
}

LPDISPATCH ICommand::GetArrayIndexCommand()
{
	LPDISPATCH result;
	GetProperty(0x2d, VT_DISPATCH, (void*)&result);
	return result;
}

void ICommand::SetArrayIndexCommand(LPDISPATCH propVal)
{
	SetProperty(0x2d, VT_DISPATCH, propVal);
}

BOOL ICommand::GetIsArrayIndex()
{
	BOOL result;
	GetProperty(0x2e, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetIsArrayIndex(BOOL propVal)
{
	SetProperty(0x2e, VT_BOOL, propVal);
}

LPDISPATCH ICommand::GetFileIOCommand()
{
	LPDISPATCH result;
	GetProperty(0x2f, VT_DISPATCH, (void*)&result);
	return result;
}

void ICommand::SetFileIOCommand(LPDISPATCH propVal)
{
	SetProperty(0x2f, VT_DISPATCH, propVal);
}

BOOL ICommand::GetIsFileIOCommand()
{
	BOOL result;
	GetProperty(0x30, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetIsFileIOCommand(BOOL propVal)
{
	SetProperty(0x30, VT_BOOL, propVal);
}

LPDISPATCH ICommand::GetTempCompCommand()
{
	LPDISPATCH result;
	GetProperty(0x31, VT_DISPATCH, (void*)&result);
	return result;
}

void ICommand::SetTempCompCommand(LPDISPATCH propVal)
{
	SetProperty(0x31, VT_DISPATCH, propVal);
}

BOOL ICommand::GetIsTempComp()
{
	BOOL result;
	GetProperty(0x32, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetIsTempComp(BOOL propVal)
{
	SetProperty(0x32, VT_BOOL, propVal);
}

LPDISPATCH ICommand::GetDisplayMetaFileCommand()
{
	LPDISPATCH result;
	GetProperty(0x33, VT_DISPATCH, (void*)&result);
	return result;
}

void ICommand::SetDisplayMetaFileCommand(LPDISPATCH propVal)
{
	SetProperty(0x33, VT_DISPATCH, propVal);
}

BOOL ICommand::GetIsDisplayMetaFile()
{
	BOOL result;
	GetProperty(0x34, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetIsDisplayMetaFile(BOOL propVal)
{
	SetProperty(0x34, VT_BOOL, propVal);
}

LPDISPATCH ICommand::GetCommentCommand()
{
	LPDISPATCH result;
	GetProperty(0x35, VT_DISPATCH, (void*)&result);
	return result;
}

void ICommand::SetCommentCommand(LPDISPATCH propVal)
{
	SetProperty(0x35, VT_DISPATCH, propVal);
}

BOOL ICommand::GetIsComment()
{
	BOOL result;
	GetProperty(0x36, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetIsComment(BOOL propVal)
{
	SetProperty(0x36, VT_BOOL, propVal);
}

LPDISPATCH ICommand::GetStatisticCommand()
{
	LPDISPATCH result;
	GetProperty(0x37, VT_DISPATCH, (void*)&result);
	return result;
}

void ICommand::SetStatisticCommand(LPDISPATCH propVal)
{
	SetProperty(0x37, VT_DISPATCH, propVal);
}

BOOL ICommand::GetIsStatistic()
{
	BOOL result;
	GetProperty(0x38, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetIsStatistic(BOOL propVal)
{
	SetProperty(0x38, VT_BOOL, propVal);
}

LPDISPATCH ICommand::GetTraceFieldCommand()
{
	LPDISPATCH result;
	GetProperty(0x39, VT_DISPATCH, (void*)&result);
	return result;
}

void ICommand::SetTraceFieldCommand(LPDISPATCH propVal)
{
	SetProperty(0x39, VT_DISPATCH, propVal);
}

BOOL ICommand::GetIsTraceField()
{
	BOOL result;
	GetProperty(0x3a, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetIsTraceField(BOOL propVal)
{
	SetProperty(0x3a, VT_BOOL, propVal);
}

LPDISPATCH ICommand::GetActiveTipCommand()
{
	LPDISPATCH result;
	GetProperty(0x3b, VT_DISPATCH, (void*)&result);
	return result;
}

void ICommand::SetActiveTipCommand(LPDISPATCH propVal)
{
	SetProperty(0x3b, VT_DISPATCH, propVal);
}

BOOL ICommand::GetIsActiveTip()
{
	BOOL result;
	GetProperty(0x3c, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetIsActiveTip(BOOL propVal)
{
	SetProperty(0x3c, VT_BOOL, propVal);
}

LPDISPATCH ICommand::GetLoadProbeCommand()
{
	LPDISPATCH result;
	GetProperty(0x3d, VT_DISPATCH, (void*)&result);
	return result;
}

void ICommand::SetLoadProbeCommand(LPDISPATCH propVal)
{
	SetProperty(0x3d, VT_DISPATCH, propVal);
}

BOOL ICommand::GetIsLoadProbe()
{
	BOOL result;
	GetProperty(0x3e, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetIsLoadProbe(BOOL propVal)
{
	SetProperty(0x3e, VT_BOOL, propVal);
}

LPDISPATCH ICommand::GetDimFormatCommand()
{
	LPDISPATCH result;
	GetProperty(0x3f, VT_DISPATCH, (void*)&result);
	return result;
}

void ICommand::SetDimFormatCommand(LPDISPATCH propVal)
{
	SetProperty(0x3f, VT_DISPATCH, propVal);
}

BOOL ICommand::GetIsDimFormat()
{
	BOOL result;
	GetProperty(0x40, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetIsDimFormat(BOOL propVal)
{
	SetProperty(0x40, VT_BOOL, propVal);
}

LPDISPATCH ICommand::GetDimInfoCommand()
{
	LPDISPATCH result;
	GetProperty(0x41, VT_DISPATCH, (void*)&result);
	return result;
}

void ICommand::SetDimInfoCommand(LPDISPATCH propVal)
{
	SetProperty(0x41, VT_DISPATCH, propVal);
}

BOOL ICommand::GetIsDimInfo()
{
	BOOL result;
	GetProperty(0x42, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetIsDimInfo(BOOL propVal)
{
	SetProperty(0x42, VT_BOOL, propVal);
}

LPDISPATCH ICommand::GetLoadMachineCommand()
{
	LPDISPATCH result;
	GetProperty(0x43, VT_DISPATCH, (void*)&result);
	return result;
}

void ICommand::SetLoadMachineCommand(LPDISPATCH propVal)
{
	SetProperty(0x43, VT_DISPATCH, propVal);
}

BOOL ICommand::GetIsLoadMachine()
{
	BOOL result;
	GetProperty(0x44, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetIsLoadMachine(BOOL propVal)
{
	SetProperty(0x44, VT_BOOL, propVal);
}

LPDISPATCH ICommand::GetScanCommand()
{
	LPDISPATCH result;
	GetProperty(0x45, VT_DISPATCH, (void*)&result);
	return result;
}

void ICommand::SetScanCommand(LPDISPATCH propVal)
{
	SetProperty(0x45, VT_DISPATCH, propVal);
}

BOOL ICommand::GetIsScan()
{
	BOOL result;
	GetProperty(0x46, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetIsScan(BOOL propVal)
{
	SetProperty(0x46, VT_BOOL, propVal);
}

BOOL ICommand::GetIsHit()
{
	BOOL result;
	GetProperty(0x47, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetIsHit(BOOL propVal)
{
	SetProperty(0x47, VT_BOOL, propVal);
}

BOOL ICommand::GetIsMeasuredFeature()
{
	BOOL result;
	GetProperty(0x48, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetIsMeasuredFeature(BOOL propVal)
{
	SetProperty(0x48, VT_BOOL, propVal);
}

BOOL ICommand::GetIsConstructedFeature()
{
	BOOL result;
	GetProperty(0x49, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetIsConstructedFeature(BOOL propVal)
{
	SetProperty(0x49, VT_BOOL, propVal);
}

BOOL ICommand::GetIsDCCFeature()
{
	BOOL result;
	GetProperty(0x4a, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetIsDCCFeature(BOOL propVal)
{
	SetProperty(0x4a, VT_BOOL, propVal);
}

BOOL ICommand::GetSlaveArm()
{
	BOOL result;
	GetProperty(0x4b, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetSlaveArm(BOOL propVal)
{
	SetProperty(0x4b, VT_BOOL, propVal);
}

BOOL ICommand::GetShowIDOnCad()
{
	BOOL result;
	GetProperty(0x4c, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetShowIDOnCad(BOOL propVal)
{
	SetProperty(0x4c, VT_BOOL, propVal);
}

BOOL ICommand::GetCopyMeasToNom()
{
	BOOL result;
	GetProperty(0x4d, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetCopyMeasToNom(BOOL propVal)
{
	SetProperty(0x4d, VT_BOOL, propVal);
}

CString ICommand::GetTypeDescription()
{
	CString result;
	GetProperty(0x4e, VT_BSTR, (void*)&result);
	return result;
}

void ICommand::SetTypeDescription(LPCTSTR propVal)
{
	SetProperty(0x4e, VT_BSTR, propVal);
}

LPDISPATCH ICommand::GetDataTypes()
{
	LPDISPATCH result;
	GetProperty(0x52, VT_DISPATCH, (void*)&result);
	return result;
}

void ICommand::SetDataTypes(LPDISPATCH propVal)
{
	SetProperty(0x52, VT_DISPATCH, propVal);
}

BOOL ICommand::GetMasterArm()
{
	BOOL result;
	GetProperty(0x57, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetMasterArm(BOOL propVal)
{
	SetProperty(0x57, VT_BOOL, propVal);
}

BOOL ICommand::GetBothArms()
{
	BOOL result;
	GetProperty(0x58, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetBothArms(BOOL propVal)
{
	SetProperty(0x58, VT_BOOL, propVal);
}

BOOL ICommand::GetRecalculateINOUT()
{
	BOOL result;
	GetProperty(0x5c, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetRecalculateINOUT(BOOL propVal)
{
	SetProperty(0x5c, VT_BOOL, propVal);
}

BOOL ICommand::GetHasBreakpoint()
{
	BOOL result;
	GetProperty(0x5e, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetHasBreakpoint(BOOL propVal)
{
	SetProperty(0x5e, VT_BOOL, propVal);
}

long ICommand::GetItemIndex()
{
	long result;
	GetProperty(0x69, VT_I4, (void*)&result);
	return result;
}

void ICommand::SetItemIndex(long propVal)
{
	SetProperty(0x69, VT_I4, propVal);
}

BOOL ICommand::GetSkipped()
{
	BOOL result;
	GetProperty(0x6b, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetSkipped(BOOL propVal)
{
	SetProperty(0x6b, VT_BOOL, propVal);
}

BOOL ICommand::GetTracksErrors()
{
	BOOL result;
	GetProperty(0x6c, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetTracksErrors(BOOL propVal)
{
	SetProperty(0x6c, VT_BOOL, propVal);
}

BOOL ICommand::GetMissedHit()
{
	BOOL result;
	GetProperty(0x6d, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetMissedHit(BOOL propVal)
{
	SetProperty(0x6d, VT_BOOL, propVal);
}

BOOL ICommand::GetUnexpectedHit()
{
	BOOL result;
	GetProperty(0x6e, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetUnexpectedHit(BOOL propVal)
{
	SetProperty(0x6e, VT_BOOL, propVal);
}

BOOL ICommand::GetExpectsMiss()
{
	BOOL result;
	GetProperty(0x6f, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetExpectsMiss(BOOL propVal)
{
	SetProperty(0x6f, VT_BOOL, propVal);
}

long ICommand::GetSlotType()
{
	long result;
	GetProperty(0x70, VT_I4, (void*)&result);
	return result;
}

void ICommand::SetSlotType(long propVal)
{
	SetProperty(0x70, VT_I4, propVal);
}

LPDISPATCH ICommand::GetDimensionEndCommand()
{
	LPDISPATCH result;
	GetProperty(0x71, VT_DISPATCH, (void*)&result);
	return result;
}

void ICommand::SetDimensionEndCommand(LPDISPATCH propVal)
{
	SetProperty(0x71, VT_DISPATCH, propVal);
}

long ICommand::GetUserDefinedUniqueID()
{
	long result;
	GetProperty(0x72, VT_I4, (void*)&result);
	return result;
}

void ICommand::SetUserDefinedUniqueID(long propVal)
{
	SetProperty(0x72, VT_I4, propVal);
}

BOOL ICommand::GetIsToolkitCommand()
{
	BOOL result;
	GetProperty(0x74, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetIsToolkitCommand(BOOL propVal)
{
	SetProperty(0x74, VT_BOOL, propVal);
}

LPDISPATCH ICommand::GetToolkitInternalCommands()
{
	LPDISPATCH result;
	GetProperty(0x7f, VT_DISPATCH, (void*)&result);
	return result;
}

void ICommand::SetToolkitInternalCommands(LPDISPATCH propVal)
{
	SetProperty(0x7f, VT_DISPATCH, propVal);
}

CString ICommand::GetDisplayID()
{
	CString result;
	GetProperty(0x80, VT_BSTR, (void*)&result);
	return result;
}

void ICommand::SetDisplayID(LPCTSTR propVal)
{
	SetProperty(0x80, VT_BSTR, propVal);
}

LPDISPATCH ICommand::GetStrategies()
{
	LPDISPATCH result;
	GetProperty(0x81, VT_DISPATCH, (void*)&result);
	return result;
}

void ICommand::SetStrategies(LPDISPATCH propVal)
{
	SetProperty(0x81, VT_DISPATCH, propVal);
}

BOOL ICommand::GetIsFCFCommand()
{
	BOOL result;
	GetProperty(0x82, VT_BOOL, (void*)&result);
	return result;
}

void ICommand::SetIsFCFCommand(BOOL propVal)
{
	SetProperty(0x82, VT_BOOL, propVal);
}

LPDISPATCH ICommand::GetFCFCommand()
{
	LPDISPATCH result;
	GetProperty(0x83, VT_DISPATCH, (void*)&result);
	return result;
}

void ICommand::SetFCFCommand(LPDISPATCH propVal)
{
	SetProperty(0x83, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// ICommand operations

BOOL ICommand::Next()
{
	BOOL result;
	InvokeHelper(0x16, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
	return result;
}

BOOL ICommand::Prev()
{
	BOOL result;
	InvokeHelper(0x17, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
	return result;
}

void ICommand::Remove()
{
	InvokeHelper(0x18, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL ICommand::Dialog()
{
	BOOL result;
	InvokeHelper(0x19, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
	return result;
}

LPDISPATCH ICommand::Item(long Num)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x1a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Num);
	return result;
}

BOOL ICommand::Dialog2(LPDISPATCH* DialogObject)
{
	BOOL result;
	static BYTE parms[] =
		VTS_PDISPATCH;
	InvokeHelper(0x1b, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		DialogObject);
	return result;
}

BOOL ICommand::SetExpression(LPCTSTR Expression, long FieldType, long TypeIndex)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR VTS_I4 VTS_I4;
	InvokeHelper(0x1c, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		Expression, FieldType, TypeIndex);
	return result;
}

CString ICommand::GetExpression(long FieldType, long TypeIndex)
{
	CString result;
	static BYTE parms[] =
		VTS_I4 VTS_I4;
	InvokeHelper(0x1d, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
		FieldType, TypeIndex);
	return result;
}

void ICommand::RemoveExpression(long FieldType, long TypeIndex)
{
	static BYTE parms[] =
		VTS_I4 VTS_I4;
	InvokeHelper(0x1e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 FieldType, TypeIndex);
}

BOOL ICommand::EXECUTE()
{
	BOOL result;
	InvokeHelper(0x1f, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
	return result;
}

void ICommand::Mark()
{
	InvokeHelper(0x20, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

CString ICommand::GetText(long DataType, long TypeIndex)
{
	CString result;
	static BYTE parms[] =
		VTS_I4 VTS_I4;
	InvokeHelper(0x4f, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
		DataType, TypeIndex);
	return result;
}

BOOL ICommand::PutText(LPCTSTR NewVal, long DataType, long TypeIndex)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR VTS_I4 VTS_I4;
	InvokeHelper(0x50, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		NewVal, DataType, TypeIndex);
	return result;
}

void ICommand::ReDraw()
{
	InvokeHelper(0x51, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ICommand::GetUniqueID(long* HiPart, long* LoPart)
{
	static BYTE parms[] =
		VTS_PI4 VTS_PI4;
	InvokeHelper(0x53, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 HiPart, LoPart);
}

BOOL ICommand::IsExpressionValid(LPCTSTR Expression)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x54, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		Expression);
	return result;
}

LPDISPATCH ICommand::SolveExpression(LPCTSTR Expression)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x55, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Expression);
	return result;
}

CString ICommand::GetToggleString(long DataType, long TypeIndex)
{
	CString result;
	static BYTE parms[] =
		VTS_I4 VTS_I4;
	InvokeHelper(0x56, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
		DataType, TypeIndex);
	return result;
}

BOOL ICommand::SetSlaveArm()
{
	BOOL result;
	InvokeHelper(0x59, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
	return result;
}

BOOL ICommand::SetMasterArm()
{
	BOOL result;
	InvokeHelper(0x5a, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
	return result;
}

BOOL ICommand::SetBothArms()
{
	BOOL result;
	InvokeHelper(0x5b, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
	return result;
}

BOOL ICommand::SetToggleString(long ToggleIndex, long DataType, long TypeIndex)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_I4;
	InvokeHelper(0x5d, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		ToggleIndex, DataType, TypeIndex);
	return result;
}

LPDISPATCH ICommand::OptimizedSolveExpression(LPCTSTR Expression)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x5f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Expression);
	return result;
}

BOOL ICommand::OptimizedSetExpression(LPCTSTR Expression, long FieldType, long TypeIndex)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR VTS_I4 VTS_I4;
	InvokeHelper(0x60, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		Expression, FieldType, TypeIndex);
	return result;
}

VARIANT ICommand::GetGetFieldValue(long DataType, long TypeIndex)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_I4 VTS_I4;
	InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms,
		DataType, TypeIndex);
	return result;
}

BOOL ICommand::GetHasField(long DataType, long TypeIndex)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4 VTS_I4;
	InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
		DataType, TypeIndex);
	return result;
}

long ICommand::GetGetToggleValue(long DataType, long TypeIndex)
{
	long result;
	static BYTE parms[] =
		VTS_I4 VTS_I4;
	InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
		DataType, TypeIndex);
	return result;
}

long ICommand::GetGetDataTypeCount(long DataType)
{
	long result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
		DataType);
	return result;
}

void ICommand::UpdateDimensionNominals(BOOL UpdateObjectText)
{
	static BYTE parms[] =
		VTS_BOOL;
	InvokeHelper(0x73, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 UpdateObjectText);
}

VARIANT ICommand::GetToolkitData(LPCTSTR sToolkitKey)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		sToolkitKey);
	return result;
}

BOOL ICommand::PutToolkitData(const VARIANT& Value, LPCTSTR sToolkitKey)
{
	BOOL result;
	static BYTE parms[] =
		VTS_VARIANT VTS_BSTR;
	InvokeHelper(0x76, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		&Value, sToolkitKey);
	return result;
}

LPDISPATCH ICommand::ToggleCommandType(const VARIANT& MinorWordOrToggleIndex)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x77, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&MinorWordOrToggleIndex);
	return result;
}

long ICommand::GetGetDataTypeCountUniqueIndex(long DataType, long TypeIndex)
{
	long result;
	static BYTE parms[] =
		VTS_I4 VTS_I4;
	InvokeHelper(0x78, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
		DataType, TypeIndex);
	return result;
}

BOOL ICommand::RemoveBundleInstance(long StationIndex)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x79, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		StationIndex);
	return result;
}

LPDISPATCH ICommand::GetBundleInstance(long StationIndex)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x7a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		StationIndex);
	return result;
}

BOOL ICommand::AddBundleInstance(long StationIndex)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x7b, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		StationIndex);
	return result;
}

BOOL ICommand::CreateBundleFeatures()
{
	BOOL result;
	InvokeHelper(0x7c, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
	return result;
}

BOOL ICommand::IsBundledCommand()
{
	BOOL result;
	InvokeHelper(0x7d, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
	return result;
}

BOOL ICommand::Compute()
{
	BOOL result;
	InvokeHelper(0x7e, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ICommands properties

LPDISPATCH ICommands::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x1, VT_DISPATCH, (void*)&result);
	return result;
}

void ICommands::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x1, VT_DISPATCH, propVal);
}

LPDISPATCH ICommands::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x2, VT_DISPATCH, (void*)&result);
	return result;
}

void ICommands::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x2, VT_DISPATCH, propVal);
}

long ICommands::GetCount()
{
	long result;
	GetProperty(0x3, VT_I4, (void*)&result);
	return result;
}

void ICommands::SetCount(long propVal)
{
	SetProperty(0x3, VT_I4, propVal);
}

LPDISPATCH ICommands::GetLastCommand()
{
	LPDISPATCH result;
	GetProperty(0xc, VT_DISPATCH, (void*)&result);
	return result;
}

void ICommands::SetLastCommand(LPDISPATCH propVal)
{
	SetProperty(0xc, VT_DISPATCH, propVal);
}

LPDISPATCH ICommands::GetCurrentCommand()
{
	LPDISPATCH result;
	GetProperty(0xd, VT_DISPATCH, (void*)&result);
	return result;
}

void ICommands::SetCurrentCommand(LPDISPATCH propVal)
{
	SetProperty(0xd, VT_DISPATCH, propVal);
}

LPDISPATCH ICommands::GetCurrentAlignment()
{
	LPDISPATCH result;
	GetProperty(0x13, VT_DISPATCH, (void*)&result);
	return result;
}

void ICommands::SetCurrentAlignment(LPDISPATCH propVal)
{
	SetProperty(0x13, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// ICommands operations

BOOL ICommands::InsertionPointAfter(LPDISPATCH Command)
{
	BOOL result;
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		Command);
	return result;
}

BOOL ICommands::MarkAll(BOOL MarkManual)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BOOL;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		MarkManual);
	return result;
}

BOOL ICommands::ClearMarked()
{
	BOOL result;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
	return result;
}

LPDISPATCH ICommands::Add(long Type, BOOL AutoPosition)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4 VTS_BOOL;
	InvokeHelper(0x8, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Type, AutoPosition);
	return result;
}

LPDISPATCH ICommands::Item(const VARIANT& NameorNum)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x9, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&NameorNum);
	return result;
}

LPDISPATCH ICommands::FindByUniqueID(long HiPart, long LoPart)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4 VTS_I4;
	InvokeHelper(0xa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		HiPart, LoPart);
	return result;
}

BOOL ICommands::ClearAllBreakpoints()
{
	BOOL result;
	InvokeHelper(0xb, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
	return result;
}

void ICommands::RemoveCommandRange(LPDISPATCH StartCommand, LPDISPATCH EndCommad)
{
	static BYTE parms[] =
		VTS_DISPATCH VTS_DISPATCH;
	InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 StartCommand, EndCommad);
}

CString ICommands::AddConstPointWithValues(long Type, LPCTSTR X, LPCTSTR Y, LPCTSTR Z, BOOL AutoPosition)
{
	CString result;
	static BYTE parms[] =
		VTS_I4 VTS_BSTR VTS_BSTR VTS_BSTR VTS_BOOL;
	InvokeHelper(0xf, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
		Type, X, Y, Z, AutoPosition);
	return result;
}

LPDISPATCH ICommands::AddDimensionWithValues(long Type, LPCTSTR strRefID, LPCTSTR strArrowMult, LPCTSTR strStdDev, BOOL AutoPosition)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4 VTS_BSTR VTS_BSTR VTS_BSTR VTS_BOOL;
	InvokeHelper(0x10, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Type, strRefID, strArrowMult, strStdDev, AutoPosition);
	return result;
}

VARIANT ICommands::AddMultiConstPoints(long Type, const VARIANT& PointArray, BOOL AutoPosition)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_I4 VTS_VARIANT VTS_BOOL;
	InvokeHelper(0x11, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		Type, &PointArray, AutoPosition);
	return result;
}

LPDISPATCH ICommands::AddByCreationGuid(LPCTSTR GuidAsString, BOOL AutoPosition)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_BSTR VTS_BOOL;
	InvokeHelper(0x12, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		GuidAsString, AutoPosition);
	return result;
}

//BOOL ICommands::SetCurrentCommand(LPDISPATCH Command)
//{
//	BOOL result;
//	static BYTE parms[] =
//		VTS_DISPATCH;
//	InvokeHelper(0x14, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
//		Command);
//	return result;
//}


LPDISPATCH ICommands::_Item(const VARIANT& NameorNum)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&NameorNum);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IAlignCommand properties

long IAlignCommand::GetAboutAxis()
{
	long result;
	GetProperty(0x1, VT_I4, (void*)&result);
	return result;
}

void IAlignCommand::SetAboutAxis(long propVal)
{
	SetProperty(0x1, VT_I4, propVal);
}

long IAlignCommand::GetAxis()
{
	long result;
	GetProperty(0x2, VT_I4, (void*)&result);
	return result;
}

void IAlignCommand::SetAxis(long propVal)
{
	SetProperty(0x2, VT_I4, propVal);
}

CString IAlignCommand::GetExternalID()
{
	CString result;
	GetProperty(0x3, VT_BSTR, (void*)&result);
	return result;
}

void IAlignCommand::SetExternalID(LPCTSTR propVal)
{
	SetProperty(0x3, VT_BSTR, propVal);
}

CString IAlignCommand::GetFeatID()
{
	CString result;
	GetProperty(0x4, VT_BSTR, (void*)&result);
	return result;
}

void IAlignCommand::SetFeatID(LPCTSTR propVal)
{
	SetProperty(0x4, VT_BSTR, propVal);
}

CString IAlignCommand::GetFeatID2()
{
	CString result;
	GetProperty(0x5, VT_BSTR, (void*)&result);
	return result;
}

void IAlignCommand::SetFeatID2(LPCTSTR propVal)
{
	SetProperty(0x5, VT_BSTR, propVal);
}

BOOL IAlignCommand::GetFindCad()
{
	BOOL result;
	GetProperty(0x6, VT_BOOL, (void*)&result);
	return result;
}

void IAlignCommand::SetFindCad(BOOL propVal)
{
	SetProperty(0x6, VT_BOOL, propVal);
}

CString IAlignCommand::GetId()
{
	CString result;
	GetProperty(0x7, VT_BSTR, (void*)&result);
	return result;
}

void IAlignCommand::SetId(LPCTSTR propVal)
{
	SetProperty(0x7, VT_BSTR, propVal);
}

CString IAlignCommand::GetInitID()
{
	CString result;
	GetProperty(0x8, VT_BSTR, (void*)&result);
	return result;
}

void IAlignCommand::SetInitID(LPCTSTR propVal)
{
	SetProperty(0x8, VT_BSTR, propVal);
}

BOOL IAlignCommand::GetMeasAllFeat()
{
	BOOL result;
	GetProperty(0x9, VT_BOOL, (void*)&result);
	return result;
}

void IAlignCommand::SetMeasAllFeat(BOOL propVal)
{
	SetProperty(0x9, VT_BOOL, propVal);
}

double IAlignCommand::GetOffset()
{
	double result;
	GetProperty(0xa, VT_R8, (void*)&result);
	return result;
}

void IAlignCommand::SetOffset(double propVal)
{
	SetProperty(0xa, VT_R8, propVal);
}

double IAlignCommand::GetPointTolerance()
{
	double result;
	GetProperty(0xb, VT_R8, (void*)&result);
	return result;
}

void IAlignCommand::SetPointTolerance(double propVal)
{
	SetProperty(0xb, VT_R8, propVal);
}

BOOL IAlignCommand::GetRepierceCad()
{
	BOOL result;
	GetProperty(0xc, VT_BOOL, (void*)&result);
	return result;
}

void IAlignCommand::SetRepierceCad(BOOL propVal)
{
	SetProperty(0xc, VT_BOOL, propVal);
}

BOOL IAlignCommand::GetUseBodyAxis()
{
	BOOL result;
	GetProperty(0xd, VT_BOOL, (void*)&result);
	return result;
}

void IAlignCommand::SetUseBodyAxis(BOOL propVal)
{
	SetProperty(0xd, VT_BOOL, propVal);
}

long IAlignCommand::GetWorkplane()
{
	long result;
	GetProperty(0xe, VT_I4, (void*)&result);
	return result;
}

void IAlignCommand::SetWorkplane(long propVal)
{
	SetProperty(0xe, VT_I4, propVal);
}

LPDISPATCH IAlignCommand::GetParent()
{
	LPDISPATCH result;
	GetProperty(0xf, VT_DISPATCH, (void*)&result);
	return result;
}

void IAlignCommand::SetParent(LPDISPATCH propVal)
{
	SetProperty(0xf, VT_DISPATCH, propVal);
}

long IAlignCommand::GetNumInputs()
{
	long result;
	GetProperty(0x10, VT_I4, (void*)&result);
	return result;
}

void IAlignCommand::SetNumInputs(long propVal)
{
	SetProperty(0x10, VT_I4, propVal);
}

LPDISPATCH IAlignCommand::GetAngle()
{
	LPDISPATCH result;
	GetProperty(0x11, VT_DISPATCH, (void*)&result);
	return result;
}

void IAlignCommand::SetAngle(LPDISPATCH propVal)
{
	SetProperty(0x11, VT_DISPATCH, propVal);
}

LPDISPATCH IAlignCommand::GetBFOffset()
{
	LPDISPATCH result;
	GetProperty(0x12, VT_DISPATCH, (void*)&result);
	return result;
}

void IAlignCommand::SetBFOffset(LPDISPATCH propVal)
{
	SetProperty(0x12, VT_DISPATCH, propVal);
}

BOOL IAlignCommand::GetAverageError()
{
	BOOL result;
	GetProperty(0x13, VT_BOOL, (void*)&result);
	return result;
}

void IAlignCommand::SetAverageError(BOOL propVal)
{
	SetProperty(0x13, VT_BOOL, propVal);
}

CString IAlignCommand::GetExternalFileID()
{
	CString result;
	GetProperty(0x14, VT_BSTR, (void*)&result);
	return result;
}

void IAlignCommand::SetExternalFileID(LPCTSTR propVal)
{
	SetProperty(0x14, VT_BSTR, propVal);
}

LPDISPATCH IAlignCommand::GetMachineToPartMatrix()
{
	LPDISPATCH result;
	GetProperty(0x1a, VT_DISPATCH, (void*)&result);
	return result;
}

void IAlignCommand::SetMachineToPartMatrix(LPDISPATCH propVal)
{
	SetProperty(0x1a, VT_DISPATCH, propVal);
}

LPDISPATCH IAlignCommand::GetCadToPartMatrix()
{
	LPDISPATCH result;
	GetProperty(0x1b, VT_DISPATCH, (void*)&result);
	return result;
}

void IAlignCommand::SetCadToPartMatrix(LPDISPATCH propVal)
{
	SetProperty(0x1b, VT_DISPATCH, propVal);
}

BOOL IAlignCommand::GetMeasAllFeatAlways()
{
	BOOL result;
	GetProperty(0x1c, VT_BOOL, (void*)&result);
	return result;
}

void IAlignCommand::SetMeasAllFeatAlways(BOOL propVal)
{
	SetProperty(0x1c, VT_BOOL, propVal);
}

long IAlignCommand::GetIterativeLevelAxis()
{
	long result;
	GetProperty(0x1d, VT_I4, (void*)&result);
	return result;
}

void IAlignCommand::SetIterativeLevelAxis(long propVal)
{
	SetProperty(0x1d, VT_I4, propVal);
}

long IAlignCommand::GetIterativeRotateAxis()
{
	long result;
	GetProperty(0x1e, VT_I4, (void*)&result);
	return result;
}

void IAlignCommand::SetIterativeRotateAxis(long propVal)
{
	SetProperty(0x1e, VT_I4, propVal);
}

long IAlignCommand::GetIterativeOriginAxis()
{
	long result;
	GetProperty(0x1f, VT_I4, (void*)&result);
	return result;
}

void IAlignCommand::SetIterativeOriginAxis(long propVal)
{
	SetProperty(0x1f, VT_I4, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IAlignCommand operations

BOOL IAlignCommand::AddLevelFeat(LPCTSTR ID)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x15, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		ID);
	return result;
}

BOOL IAlignCommand::AddRotateFeat(LPCTSTR ID)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x16, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		ID);
	return result;
}

BOOL IAlignCommand::AddOriginFeat(LPCTSTR ID)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x17, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		ID);
	return result;
}

BOOL IAlignCommand::AddBestFitFeat(LPCTSTR ID, double Tolerance)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR VTS_R8;
	InvokeHelper(0x18, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		ID, Tolerance);
	return result;
}

void IAlignCommand::CalculateMatrices()
{
	InvokeHelper(0x19, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL IAlignCommand::CalculateDeviation(long Item, double* deviation_before, double* ijk_before, double* deviation_after, double* ijk_after)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4 VTS_PR8 VTS_PR8 VTS_PR8 VTS_PR8;
	InvokeHelper(0x20, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		Item, deviation_before, ijk_before, deviation_after, ijk_after);
	return result;
}

void IAlignCommand::CalculateStatistics(double* MEAN, double* STDDEV)
{
	static BYTE parms[] =
		VTS_PR8 VTS_PR8;
	InvokeHelper(0x21, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 MEAN, STDDEV);
}

CString IAlignCommand::GetFeatureIdByIndex(long index)
{
	CString result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x22, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
		index);
	return result;
}

void IAlignCommand::GetBFIterations(long* max_iterations, long* actual_iterations)
{
	static BYTE parms[] =
		VTS_PI4 VTS_PI4;
	InvokeHelper(0x23, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 max_iterations, actual_iterations);
}

BOOL IAlignCommand::CalculateDeviation2(long Item, long* nAxisUsed, double* dTheoXYZAfter, double* dMeasXYZAfter, double* dDeviationAfter, double* dIJKAfter)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4 VTS_PI4 VTS_PR8 VTS_PR8 VTS_PR8 VTS_PR8;
	InvokeHelper(0x24, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		Item, nAxisUsed, dTheoXYZAfter, dMeasXYZAfter, dDeviationAfter, dIJKAfter);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IPoint properties

double IPoint::GetX()
{
	double result;
	GetProperty(0x1, VT_R8, (void*)&result);
	return result;
}

void IPoint::SetX(double propVal)
{
	SetProperty(0x1, VT_R8, propVal);
}

double IPoint::GetY()
{
	double result;
	GetProperty(0x2, VT_R8, (void*)&result);
	return result;
}

void IPoint::SetY(double propVal)
{
	SetProperty(0x2, VT_R8, propVal);
}

double IPoint::GetZ()
{
	double result;
	GetProperty(0x3, VT_R8, (void*)&result);
	return result;
}

void IPoint::SetZ(double propVal)
{
	SetProperty(0x3, VT_R8, propVal);
}

double IPoint::GetI()
{
	double result;
	GetProperty(0x4, VT_R8, (void*)&result);
	return result;
}

void IPoint::SetI(double propVal)
{
	SetProperty(0x4, VT_R8, propVal);
}

double IPoint::GetJ()
{
	double result;
	GetProperty(0x5, VT_R8, (void*)&result);
	return result;
}

void IPoint::SetJ(double propVal)
{
	SetProperty(0x5, VT_R8, propVal);
}

double IPoint::GetK()
{
	double result;
	GetProperty(0x6, VT_R8, (void*)&result);
	return result;
}

void IPoint::SetK(double propVal)
{
	SetProperty(0x6, VT_R8, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IPoint operations

void IPoint::XYZ(double X, double Y, double Z)
{
	static BYTE parms[] =
		VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 X, Y, Z);
}

void IPoint::IJK(double I, double J, double K)
{
	static BYTE parms[] =
		VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0x8, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 I, J, K);
}


/////////////////////////////////////////////////////////////////////////////
// IDmisMatrix properties

LPDISPATCH IDmisMatrix::GetPrimaryAxis()
{
	LPDISPATCH result;
	GetProperty(0x1, VT_DISPATCH, (void*)&result);
	return result;
}

void IDmisMatrix::SetPrimaryAxis(LPDISPATCH propVal)
{
	SetProperty(0x1, VT_DISPATCH, propVal);
}

LPDISPATCH IDmisMatrix::GetSecondaryAxis()
{
	LPDISPATCH result;
	GetProperty(0x2, VT_DISPATCH, (void*)&result);
	return result;
}

void IDmisMatrix::SetSecondaryAxis(LPDISPATCH propVal)
{
	SetProperty(0x2, VT_DISPATCH, propVal);
}

LPDISPATCH IDmisMatrix::GetTertiaryAxis()
{
	LPDISPATCH result;
	GetProperty(0x3, VT_DISPATCH, (void*)&result);
	return result;
}

void IDmisMatrix::SetTertiaryAxis(LPDISPATCH propVal)
{
	SetProperty(0x3, VT_DISPATCH, propVal);
}

LPDISPATCH IDmisMatrix::GetOffset()
{
	LPDISPATCH result;
	GetProperty(0x4, VT_DISPATCH, (void*)&result);
	return result;
}

void IDmisMatrix::SetOffset(LPDISPATCH propVal)
{
	SetProperty(0x4, VT_DISPATCH, propVal);
}

BOOL IDmisMatrix::GetIsIdentity()
{
	BOOL result;
	GetProperty(0x5, VT_BOOL, (void*)&result);
	return result;
}

void IDmisMatrix::SetIsIdentity(BOOL propVal)
{
	SetProperty(0x5, VT_BOOL, propVal);
}

LPDISPATCH IDmisMatrix::GetCopy()
{
	LPDISPATCH result;
	GetProperty(0x6, VT_DISPATCH, (void*)&result);
	return result;
}

void IDmisMatrix::SetCopy(LPDISPATCH propVal)
{
	SetProperty(0x6, VT_DISPATCH, propVal);
}

LPDISPATCH IDmisMatrix::GetInverse()
{
	LPDISPATCH result;
	GetProperty(0x7, VT_DISPATCH, (void*)&result);
	return result;
}

void IDmisMatrix::SetInverse(LPDISPATCH propVal)
{
	SetProperty(0x7, VT_DISPATCH, propVal);
}

LPDISPATCH IDmisMatrix::Get_Copy()
{
	LPDISPATCH result;
	GetProperty(0x0, VT_DISPATCH, (void*)&result);
	return result;
}

void IDmisMatrix::Set_Copy(LPDISPATCH propVal)
{
	SetProperty(0x0, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IDmisMatrix operations

void IDmisMatrix::Reset()
{
	InvokeHelper(0x8, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDmisMatrix::Normalize()
{
	InvokeHelper(0x9, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDmisMatrix::SetMatrix(LPDISPATCH Vector, LPDISPATCH Point, long Workplane)
{
	static BYTE parms[] =
		VTS_DISPATCH VTS_DISPATCH VTS_I4;
	InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Vector, Point, Workplane);
}

void IDmisMatrix::RotateByAngle(double Angle, long Workplane)
{
	static BYTE parms[] =
		VTS_R8 VTS_I4;
	InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Angle, Workplane);
}

void IDmisMatrix::RotateToPoint(double X, double Y, long Workplane)
{
	static BYTE parms[] =
		VTS_R8 VTS_R8 VTS_I4;
	InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 X, Y, Workplane);
}

void IDmisMatrix::RotateToVector(LPDISPATCH Vector, long Workplane)
{
	static BYTE parms[] =
		VTS_DISPATCH VTS_I4;
	InvokeHelper(0xd, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Vector, Workplane);
}

void IDmisMatrix::TransformDataBack(LPDISPATCH* PointData, long TransformationType, long Workplane)
{
	static BYTE parms[] =
		VTS_PDISPATCH VTS_I4 VTS_I4;
	InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 PointData, TransformationType, Workplane);
}

void IDmisMatrix::TransformDataForward(LPDISPATCH* PointData, long TransformationType, long Workplane)
{
	static BYTE parms[] =
		VTS_PDISPATCH VTS_I4 VTS_I4;
	InvokeHelper(0xf, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 PointData, TransformationType, Workplane);
}

double IDmisMatrix::Item(long Num)
{
	double result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x10, DISPATCH_METHOD, VT_R8, (void*)&result, parms,
		Num);
	return result;
}

LPDISPATCH IDmisMatrix::Multiply(LPDISPATCH SecondMatrix)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x11, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		SecondMatrix);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IDimensionCmd properties

double IDimensionCmd::GetAngle()
{
	double result;
	GetProperty(0x1, VT_R8, (void*)&result);
	return result;
}

void IDimensionCmd::SetAngle(double propVal)
{
	SetProperty(0x1, VT_R8, propVal);
}

double IDimensionCmd::GetBonus()
{
	double result;
	GetProperty(0x2, VT_R8, (void*)&result);
	return result;
}

void IDimensionCmd::SetBonus(double propVal)
{
	SetProperty(0x2, VT_R8, propVal);
}

double IDimensionCmd::GetDeviation()
{
	double result;
	GetProperty(0x3, VT_R8, (void*)&result);
	return result;
}

void IDimensionCmd::SetDeviation(double propVal)
{
	SetProperty(0x3, VT_R8, propVal);
}

double IDimensionCmd::GetDevAngle()
{
	double result;
	GetProperty(0x4, VT_R8, (void*)&result);
	return result;
}

void IDimensionCmd::SetDevAngle(double propVal)
{
	SetProperty(0x4, VT_R8, propVal);
}

CString IDimensionCmd::GetId()
{
	CString result;
	GetProperty(0x5, VT_BSTR, (void*)&result);
	return result;
}

void IDimensionCmd::SetId(LPCTSTR propVal)
{
	SetProperty(0x5, VT_BSTR, propVal);
}

CString IDimensionCmd::GetFeat1()
{
	CString result;
	GetProperty(0x6, VT_BSTR, (void*)&result);
	return result;
}

void IDimensionCmd::SetFeat1(LPCTSTR propVal)
{
	SetProperty(0x6, VT_BSTR, propVal);
}

CString IDimensionCmd::GetFeat2()
{
	CString result;
	GetProperty(0x7, VT_BSTR, (void*)&result);
	return result;
}

void IDimensionCmd::SetFeat2(LPCTSTR propVal)
{
	SetProperty(0x7, VT_BSTR, propVal);
}

CString IDimensionCmd::GetFeat3()
{
	CString result;
	GetProperty(0x8, VT_BSTR, (void*)&result);
	return result;
}

void IDimensionCmd::SetFeat3(LPCTSTR propVal)
{
	SetProperty(0x8, VT_BSTR, propVal);
}

double IDimensionCmd::GetLength()
{
	double result;
	GetProperty(0x9, VT_R8, (void*)&result);
	return result;
}

void IDimensionCmd::SetLength(double propVal)
{
	SetProperty(0x9, VT_R8, propVal);
}

double IDimensionCmd::GetNominal()
{
	double result;
	GetProperty(0xa, VT_R8, (void*)&result);
	return result;
}

void IDimensionCmd::SetNominal(double propVal)
{
	SetProperty(0xa, VT_R8, propVal);
}

double IDimensionCmd::GetMax()
{
	double result;
	GetProperty(0xb, VT_R8, (void*)&result);
	return result;
}

void IDimensionCmd::SetMax(double propVal)
{
	SetProperty(0xb, VT_R8, propVal);
}

double IDimensionCmd::GetMeasured()
{
	double result;
	GetProperty(0xc, VT_R8, (void*)&result);
	return result;
}

void IDimensionCmd::SetMeasured(double propVal)
{
	SetProperty(0xc, VT_R8, propVal);
}

double IDimensionCmd::GetMin()
{
	double result;
	GetProperty(0xd, VT_R8, (void*)&result);
	return result;
}

void IDimensionCmd::SetMin(double propVal)
{
	SetProperty(0xd, VT_R8, propVal);
}

double IDimensionCmd::GetMinus()
{
	double result;
	GetProperty(0xe, VT_R8, (void*)&result);
	return result;
}

void IDimensionCmd::SetMinus(double propVal)
{
	SetProperty(0xe, VT_R8, propVal);
}

double IDimensionCmd::GetPlus()
{
	double result;
	GetProperty(0xf, VT_R8, (void*)&result);
	return result;
}

void IDimensionCmd::SetPlus(double propVal)
{
	SetProperty(0xf, VT_R8, propVal);
}

double IDimensionCmd::GetOutTol()
{
	double result;
	GetProperty(0x10, VT_R8, (void*)&result);
	return result;
}

void IDimensionCmd::SetOutTol(double propVal)
{
	SetProperty(0x10, VT_R8, propVal);
}

LPDISPATCH IDimensionCmd::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x11, VT_DISPATCH, (void*)&result);
	return result;
}

void IDimensionCmd::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x11, VT_DISPATCH, propVal);
}

long IDimensionCmd::GetAxis()
{
	long result;
	GetProperty(0x12, VT_I4, (void*)&result);
	return result;
}

void IDimensionCmd::SetAxis(long propVal)
{
	SetProperty(0x12, VT_I4, propVal);
}

BOOL IDimensionCmd::GetGraphicalAnalysis()
{
	BOOL result;
	GetProperty(0x13, VT_BOOL, (void*)&result);
	return result;
}

void IDimensionCmd::SetGraphicalAnalysis(BOOL propVal)
{
	SetProperty(0x13, VT_BOOL, propVal);
}

BOOL IDimensionCmd::GetTextualAnalysis()
{
	BOOL result;
	GetProperty(0x14, VT_BOOL, (void*)&result);
	return result;
}

void IDimensionCmd::SetTextualAnalysis(BOOL propVal)
{
	SetProperty(0x14, VT_BOOL, propVal);
}

double IDimensionCmd::GetArrowMultiplier()
{
	double result;
	GetProperty(0x15, VT_R8, (void*)&result);
	return result;
}

void IDimensionCmd::SetArrowMultiplier(double propVal)
{
	SetProperty(0x15, VT_R8, propVal);
}

long IDimensionCmd::GetOutputMode()
{
	long result;
	GetProperty(0x16, VT_I4, (void*)&result);
	return result;
}

void IDimensionCmd::SetOutputMode(long propVal)
{
	SetProperty(0x16, VT_I4, propVal);
}

long IDimensionCmd::GetParallelPerpendicular()
{
	long result;
	GetProperty(0x17, VT_I4, (void*)&result);
	return result;
}

void IDimensionCmd::SetParallelPerpendicular(long propVal)
{
	SetProperty(0x17, VT_I4, propVal);
}

long IDimensionCmd::GetRadiusType()
{
	long result;
	GetProperty(0x18, VT_I4, (void*)&result);
	return result;
}

void IDimensionCmd::SetRadiusType(long propVal)
{
	SetProperty(0x18, VT_I4, propVal);
}

long IDimensionCmd::GetUnits()
{
	long result;
	GetProperty(0x19, VT_I4, (void*)&result);
	return result;
}

void IDimensionCmd::SetUnits(long propVal)
{
	SetProperty(0x19, VT_I4, propVal);
}

long IDimensionCmd::GetProfile()
{
	long result;
	GetProperty(0x1a, VT_I4, (void*)&result);
	return result;
}

void IDimensionCmd::SetProfile(long propVal)
{
	SetProperty(0x1a, VT_I4, propVal);
}

long IDimensionCmd::GetTruePositionModifier()
{
	long result;
	GetProperty(0x1b, VT_I4, (void*)&result);
	return result;
}

void IDimensionCmd::SetTruePositionModifier(long propVal)
{
	SetProperty(0x1b, VT_I4, propVal);
}

long IDimensionCmd::GetTruePosUseAxis()
{
	long result;
	GetProperty(0x1c, VT_I4, (void*)&result);
	return result;
}

void IDimensionCmd::SetTruePosUseAxis(long propVal)
{
	SetProperty(0x1c, VT_I4, propVal);
}

CString IDimensionCmd::GetAxisLetter()
{
	CString result;
	GetProperty(0x1d, VT_BSTR, (void*)&result);
	return result;
}

void IDimensionCmd::SetAxisLetter(LPCTSTR propVal)
{
	SetProperty(0x1d, VT_BSTR, propVal);
}

BOOL IDimensionCmd::GetIsLocationAxis()
{
	BOOL result;
	GetProperty(0x1e, VT_BOOL, (void*)&result);
	return result;
}

void IDimensionCmd::SetIsLocationAxis(BOOL propVal)
{
	SetProperty(0x1e, VT_BOOL, propVal);
}

BOOL IDimensionCmd::GetIsTruePosAxis()
{
	BOOL result;
	GetProperty(0x1f, VT_BOOL, (void*)&result);
	return result;
}

void IDimensionCmd::SetIsTruePosAxis(BOOL propVal)
{
	SetProperty(0x1f, VT_BOOL, propVal);
}

CString IDimensionCmd::GetDatum1()
{
	CString result;
	GetProperty(0x20, VT_BSTR, (void*)&result);
	return result;
}

void IDimensionCmd::SetDatum1(LPCTSTR propVal)
{
	SetProperty(0x20, VT_BSTR, propVal);
}

CString IDimensionCmd::GetDatum2()
{
	CString result;
	GetProperty(0x21, VT_BSTR, (void*)&result);
	return result;
}

void IDimensionCmd::SetDatum2(LPCTSTR propVal)
{
	SetProperty(0x21, VT_BSTR, propVal);
}

CString IDimensionCmd::GetDatum3()
{
	CString result;
	GetProperty(0x22, VT_BSTR, (void*)&result);
	return result;
}

void IDimensionCmd::SetDatum3(LPCTSTR propVal)
{
	SetProperty(0x22, VT_BSTR, propVal);
}

long IDimensionCmd::GetTruePositionDatumModifier()
{
	long result;
	GetProperty(0x23, VT_I4, (void*)&result);
	return result;
}

void IDimensionCmd::SetTruePositionDatumModifier(long propVal)
{
	SetProperty(0x23, VT_I4, propVal);
}

long IDimensionCmd::GetDimensionModifier()
{
	long result;
	GetProperty(0x25, VT_I4, (void*)&result);
	return result;
}

void IDimensionCmd::SetDimensionModifier(long propVal)
{
	SetProperty(0x25, VT_I4, propVal);
}

long IDimensionCmd::GetDatum1Modifier()
{
	long result;
	GetProperty(0x26, VT_I4, (void*)&result);
	return result;
}

void IDimensionCmd::SetDatum1Modifier(long propVal)
{
	SetProperty(0x26, VT_I4, propVal);
}

long IDimensionCmd::GetDatum2Modifier()
{
	long result;
	GetProperty(0x27, VT_I4, (void*)&result);
	return result;
}

void IDimensionCmd::SetDatum2Modifier(long propVal)
{
	SetProperty(0x27, VT_I4, propVal);
}

long IDimensionCmd::GetDatum3Modifier()
{
	long result;
	GetProperty(0x28, VT_I4, (void*)&result);
	return result;
}

void IDimensionCmd::SetDatum3Modifier(long propVal)
{
	SetProperty(0x28, VT_I4, propVal);
}

BOOL IDimensionCmd::GetIsProfileDimension()
{
	BOOL result;
	GetProperty(0x2a, VT_BOOL, (void*)&result);
	return result;
}

void IDimensionCmd::SetIsProfileDimension(BOOL propVal)
{
	SetProperty(0x2a, VT_BOOL, propVal);
}

long IDimensionCmd::GetProfilePointInfoCount()
{
	long result;
	GetProperty(0x2b, VT_I4, (void*)&result);
	return result;
}

void IDimensionCmd::SetProfilePointInfoCount(long propVal)
{
	SetProperty(0x2b, VT_I4, propVal);
}

long IDimensionCmd::GetAngle2DToFrom()
{
	long result;
	GetProperty(0x2d, VT_I4, (void*)&result);
	return result;
}

void IDimensionCmd::SetAngle2DToFrom(long propVal)
{
	SetProperty(0x2d, VT_I4, propVal);
}

long IDimensionCmd::GetAngle2DSupplemental()
{
	long result;
	GetProperty(0x2e, VT_I4, (void*)&result);
	return result;
}

void IDimensionCmd::SetAngle2DSupplemental(long propVal)
{
	SetProperty(0x2e, VT_I4, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IDimensionCmd operations

void IDimensionCmd::Evaluate()
{
	InvokeHelper(0x24, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDimensionCmd::AddAxes()
{
	InvokeHelper(0x29, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

VARIANT IDimensionCmd::GetProfilePointInfos(long InfoType, long CoordSystem, LPCTSTR Alignment)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_BSTR;
	InvokeHelper(0x2c, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		InfoType, CoordSystem, Alignment);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IFeatCmd properties

CString IFeatCmd::GetId()
{
	CString result;
	GetProperty(0x1, VT_BSTR, (void*)&result);
	return result;
}

void IFeatCmd::SetId(LPCTSTR propVal)
{
	SetProperty(0x1, VT_BSTR, propVal);
}

long IFeatCmd::GetNumHits()
{
	long result;
	GetProperty(0x2, VT_I4, (void*)&result);
	return result;
}

void IFeatCmd::SetNumHits(long propVal)
{
	SetProperty(0x2, VT_I4, propVal);
}

LPDISPATCH IFeatCmd::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x3, VT_DISPATCH, (void*)&result);
	return result;
}

void IFeatCmd::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x3, VT_DISPATCH, propVal);
}

double IFeatCmd::GetPermHits()
{
	double result;
	GetProperty(0x4, VT_R8, (void*)&result);
	return result;
}

void IFeatCmd::SetPermHits(double propVal)
{
	SetProperty(0x4, VT_R8, propVal);
}

double IFeatCmd::GetIndent()
{
	double result;
	GetProperty(0x5, VT_R8, (void*)&result);
	return result;
}

void IFeatCmd::SetIndent(double propVal)
{
	SetProperty(0x5, VT_R8, propVal);
}

double IFeatCmd::GetThickness()
{
	double result;
	GetProperty(0x6, VT_R8, (void*)&result);
	return result;
}

void IFeatCmd::SetThickness(double propVal)
{
	SetProperty(0x6, VT_R8, propVal);
}

double IFeatCmd::GetSpacer()
{
	double result;
	GetProperty(0x7, VT_R8, (void*)&result);
	return result;
}

void IFeatCmd::SetSpacer(double propVal)
{
	SetProperty(0x7, VT_R8, propVal);
}

double IFeatCmd::GetAutoMoveDistance()
{
	double result;
	GetProperty(0x8, VT_R8, (void*)&result);
	return result;
}

void IFeatCmd::SetAutoMoveDistance(double propVal)
{
	SetProperty(0x8, VT_R8, propVal);
}

BOOL IFeatCmd::GetInner()
{
	BOOL result;
	GetProperty(0x9, VT_BOOL, (void*)&result);
	return result;
}

void IFeatCmd::SetInner(BOOL propVal)
{
	SetProperty(0x9, VT_BOOL, propVal);
}

BOOL IFeatCmd::GetUsePin()
{
	BOOL result;
	GetProperty(0xa, VT_BOOL, (void*)&result);
	return result;
}

void IFeatCmd::SetUsePin(BOOL propVal)
{
	SetProperty(0xa, VT_BOOL, propVal);
}

BOOL IFeatCmd::GetAutoReadPos()
{
	BOOL result;
	GetProperty(0xb, VT_BOOL, (void*)&result);
	return result;
}

void IFeatCmd::SetAutoReadPos(BOOL propVal)
{
	SetProperty(0xb, VT_BOOL, propVal);
}

BOOL IFeatCmd::GetAutoMove()
{
	BOOL result;
	GetProperty(0xc, VT_BOOL, (void*)&result);
	return result;
}

void IFeatCmd::SetAutoMove(BOOL propVal)
{
	SetProperty(0xc, VT_BOOL, propVal);
}

BOOL IFeatCmd::GetFindHole()
{
	BOOL result;
	GetProperty(0xd, VT_BOOL, (void*)&result);
	return result;
}

void IFeatCmd::SetFindHole(BOOL propVal)
{
	SetProperty(0xd, VT_BOOL, propVal);
}

double IFeatCmd::GetStartAngle()
{
	double result;
	GetProperty(0xe, VT_R8, (void*)&result);
	return result;
}

void IFeatCmd::SetStartAngle(double propVal)
{
	SetProperty(0xe, VT_R8, propVal);
}

double IFeatCmd::GetEndAngle()
{
	double result;
	GetProperty(0xf, VT_R8, (void*)&result);
	return result;
}

void IFeatCmd::SetEndAngle(double propVal)
{
	SetProperty(0xf, VT_R8, propVal);
}

double IFeatCmd::GetStartAngle2()
{
	double result;
	GetProperty(0x10, VT_R8, (void*)&result);
	return result;
}

void IFeatCmd::SetStartAngle2(double propVal)
{
	SetProperty(0x10, VT_R8, propVal);
}

double IFeatCmd::GetEndAngle2()
{
	double result;
	GetProperty(0x11, VT_R8, (void*)&result);
	return result;
}

void IFeatCmd::SetEndAngle2(double propVal)
{
	SetProperty(0x11, VT_R8, propVal);
}

double IFeatCmd::GetInitHits()
{
	double result;
	GetProperty(0x12, VT_R8, (void*)&result);
	return result;
}

void IFeatCmd::SetInitHits(double propVal)
{
	SetProperty(0x12, VT_R8, propVal);
}

double IFeatCmd::GetDepth()
{
	double result;
	GetProperty(0x13, VT_R8, (void*)&result);
	return result;
}

void IFeatCmd::SetDepth(double propVal)
{
	SetProperty(0x13, VT_R8, propVal);
}

double IFeatCmd::GetTheoDiam()
{
	double result;
	GetProperty(0x14, VT_R8, (void*)&result);
	return result;
}

void IFeatCmd::SetTheoDiam(double propVal)
{
	SetProperty(0x14, VT_R8, propVal);
}

double IFeatCmd::GetTheoLength()
{
	double result;
	GetProperty(0x15, VT_R8, (void*)&result);
	return result;
}

void IFeatCmd::SetTheoLength(double propVal)
{
	SetProperty(0x15, VT_R8, propVal);
}

double IFeatCmd::GetMeasDiam()
{
	double result;
	GetProperty(0x16, VT_R8, (void*)&result);
	return result;
}

void IFeatCmd::SetMeasDiam(double propVal)
{
	SetProperty(0x16, VT_R8, propVal);
}

double IFeatCmd::GetMeasLength()
{
	double result;
	GetProperty(0x17, VT_R8, (void*)&result);
	return result;
}

void IFeatCmd::SetMeasLength(double propVal)
{
	SetProperty(0x17, VT_R8, propVal);
}

double IFeatCmd::GetMeasPinDiam()
{
	double result;
	GetProperty(0x18, VT_R8, (void*)&result);
	return result;
}

void IFeatCmd::SetMeasPinDiam(double propVal)
{
	SetProperty(0x18, VT_R8, propVal);
}

double IFeatCmd::GetTheoPinDiam()
{
	double result;
	GetProperty(0x19, VT_R8, (void*)&result);
	return result;
}

void IFeatCmd::SetTheoPinDiam(double propVal)
{
	SetProperty(0x19, VT_R8, propVal);
}

CString IFeatCmd::GetRMeasFeature()
{
	CString result;
	GetProperty(0x1a, VT_BSTR, (void*)&result);
	return result;
}

void IFeatCmd::SetRMeasFeature(LPCTSTR propVal)
{
	SetProperty(0x1a, VT_BSTR, propVal);
}

double IFeatCmd::GetIndent2()
{
	double result;
	GetProperty(0x1b, VT_R8, (void*)&result);
	return result;
}

void IFeatCmd::SetIndent2(double propVal)
{
	SetProperty(0x1b, VT_R8, propVal);
}

double IFeatCmd::GetMeasAngle()
{
	double result;
	GetProperty(0x1c, VT_R8, (void*)&result);
	return result;
}

void IFeatCmd::SetMeasAngle(double propVal)
{
	SetProperty(0x1c, VT_R8, propVal);
}

double IFeatCmd::GetTheoAngle()
{
	double result;
	GetProperty(0x1d, VT_R8, (void*)&result);
	return result;
}

void IFeatCmd::SetTheoAngle(double propVal)
{
	SetProperty(0x1d, VT_R8, propVal);
}

double IFeatCmd::GetMeasSmallLength()
{
	double result;
	GetProperty(0x1e, VT_R8, (void*)&result);
	return result;
}

void IFeatCmd::SetMeasSmallLength(double propVal)
{
	SetProperty(0x1e, VT_R8, propVal);
}

double IFeatCmd::GetTheoSmallLength()
{
	double result;
	GetProperty(0x1f, VT_R8, (void*)&result);
	return result;
}

void IFeatCmd::SetTheoSmallLength(double propVal)
{
	SetProperty(0x1f, VT_R8, propVal);
}

long IFeatCmd::GetNumRows()
{
	long result;
	GetProperty(0x20, VT_I4, (void*)&result);
	return result;
}

void IFeatCmd::SetNumRows(long propVal)
{
	SetProperty(0x20, VT_I4, propVal);
}

long IFeatCmd::GetNumHitsPerRow()
{
	long result;
	GetProperty(0x21, VT_I4, (void*)&result);
	return result;
}

void IFeatCmd::SetNumHitsPerRow(long propVal)
{
	SetProperty(0x21, VT_I4, propVal);
}

long IFeatCmd::GetEdgeMeasureOrder()
{
	long result;
	GetProperty(0x22, VT_I4, (void*)&result);
	return result;
}

void IFeatCmd::SetEdgeMeasureOrder(long propVal)
{
	SetProperty(0x22, VT_I4, propVal);
}

double IFeatCmd::GetEdgeThickness()
{
	double result;
	GetProperty(0x23, VT_R8, (void*)&result);
	return result;
}

void IFeatCmd::SetEdgeThickness(double propVal)
{
	SetProperty(0x23, VT_R8, propVal);
}

double IFeatCmd::GetIndent3()
{
	double result;
	GetProperty(0x24, VT_R8, (void*)&result);
	return result;
}

void IFeatCmd::SetIndent3(double propVal)
{
	SetProperty(0x24, VT_R8, propVal);
}

double IFeatCmd::GetTheoMajorAxis()
{
	double result;
	GetProperty(0x25, VT_R8, (void*)&result);
	return result;
}

void IFeatCmd::SetTheoMajorAxis(double propVal)
{
	SetProperty(0x25, VT_R8, propVal);
}

double IFeatCmd::GetTheoMinorAxis()
{
	double result;
	GetProperty(0x26, VT_R8, (void*)&result);
	return result;
}

void IFeatCmd::SetTheoMinorAxis(double propVal)
{
	SetProperty(0x26, VT_R8, propVal);
}

double IFeatCmd::GetMeasMajorAxis()
{
	double result;
	GetProperty(0x27, VT_R8, (void*)&result);
	return result;
}

void IFeatCmd::SetMeasMajorAxis(double propVal)
{
	SetProperty(0x27, VT_R8, propVal);
}

double IFeatCmd::GetMeasMinorAxis()
{
	double result;
	GetProperty(0x28, VT_R8, (void*)&result);
	return result;
}

void IFeatCmd::SetMeasMinorAxis(double propVal)
{
	SetProperty(0x28, VT_R8, propVal);
}

long IFeatCmd::GetHighPointSearchMode()
{
	long result;
	GetProperty(0x29, VT_I4, (void*)&result);
	return result;
}

void IFeatCmd::SetHighPointSearchMode(long propVal)
{
	SetProperty(0x29, VT_I4, propVal);
}

double IFeatCmd::GetIncrement()
{
	double result;
	GetProperty(0x2a, VT_R8, (void*)&result);
	return result;
}

void IFeatCmd::SetIncrement(double propVal)
{
	SetProperty(0x2a, VT_R8, propVal);
}

double IFeatCmd::GetTolerance()
{
	double result;
	GetProperty(0x2b, VT_R8, (void*)&result);
	return result;
}

void IFeatCmd::SetTolerance(double propVal)
{
	SetProperty(0x2b, VT_R8, propVal);
}

double IFeatCmd::GetBoxWidth()
{
	double result;
	GetProperty(0x2c, VT_R8, (void*)&result);
	return result;
}

void IFeatCmd::SetBoxWidth(double propVal)
{
	SetProperty(0x2c, VT_R8, propVal);
}

double IFeatCmd::GetBoxLength()
{
	double result;
	GetProperty(0x2d, VT_R8, (void*)&result);
	return result;
}

void IFeatCmd::SetBoxLength(double propVal)
{
	SetProperty(0x2d, VT_R8, propVal);
}

double IFeatCmd::GetCircularRadiusOut()
{
	double result;
	GetProperty(0x2e, VT_R8, (void*)&result);
	return result;
}

void IFeatCmd::SetCircularRadiusOut(double propVal)
{
	SetProperty(0x2e, VT_R8, propVal);
}

double IFeatCmd::GetCircularRadiusIn()
{
	double result;
	GetProperty(0x2f, VT_R8, (void*)&result);
	return result;
}

void IFeatCmd::SetCircularRadiusIn(double propVal)
{
	SetProperty(0x2f, VT_R8, propVal);
}

double IFeatCmd::GetCornerRadius()
{
	double result;
	GetProperty(0x30, VT_R8, (void*)&result);
	return result;
}

void IFeatCmd::SetCornerRadius(double propVal)
{
	SetProperty(0x30, VT_R8, propVal);
}

double IFeatCmd::GetTheoHeight()
{
	double result;
	GetProperty(0x31, VT_R8, (void*)&result);
	return result;
}

void IFeatCmd::SetTheoHeight(double propVal)
{
	SetProperty(0x31, VT_R8, propVal);
}

double IFeatCmd::GetMeasHeight()
{
	double result;
	GetProperty(0x32, VT_R8, (void*)&result);
	return result;
}

void IFeatCmd::SetMeasHeight(double propVal)
{
	SetProperty(0x32, VT_R8, propVal);
}

double IFeatCmd::GetDeviation()
{
	double result;
	GetProperty(0x33, VT_R8, (void*)&result);
	return result;
}

void IFeatCmd::SetDeviation(double propVal)
{
	SetProperty(0x33, VT_R8, propVal);
}

BOOL IFeatCmd::GetMeasureSlotWidth()
{
	BOOL result;
	GetProperty(0x34, VT_BOOL, (void*)&result);
	return result;
}

void IFeatCmd::SetMeasureSlotWidth(BOOL propVal)
{
	SetProperty(0x34, VT_BOOL, propVal);
}

long IFeatCmd::GetAlignWorkPlane()
{
	long result;
	GetProperty(0x35, VT_I4, (void*)&result);
	return result;
}

void IFeatCmd::SetAlignWorkPlane(long propVal)
{
	SetProperty(0x35, VT_I4, propVal);
}

long IFeatCmd::GetGenericType()
{
	long result;
	GetProperty(0x36, VT_I4, (void*)&result);
	return result;
}

void IFeatCmd::SetGenericType(long propVal)
{
	SetProperty(0x36, VT_I4, propVal);
}

long IFeatCmd::GetGenericDisplayMode()
{
	long result;
	GetProperty(0x37, VT_I4, (void*)&result);
	return result;
}

void IFeatCmd::SetGenericDisplayMode(long propVal)
{
	SetProperty(0x37, VT_I4, propVal);
}

long IFeatCmd::GetGenericAlignMode()
{
	long result;
	GetProperty(0x38, VT_I4, (void*)&result);
	return result;
}

void IFeatCmd::SetGenericAlignMode(long propVal)
{
	SetProperty(0x38, VT_I4, propVal);
}

long IFeatCmd::GetFilterType()
{
	long result;
	GetProperty(0x39, VT_I4, (void*)&result);
	return result;
}

void IFeatCmd::SetFilterType(long propVal)
{
	SetProperty(0x39, VT_I4, propVal);
}

BOOL IFeatCmd::GetPolar()
{
	BOOL result;
	GetProperty(0x4c, VT_BOOL, (void*)&result);
	return result;
}

void IFeatCmd::SetPolar(BOOL propVal)
{
	SetProperty(0x4c, VT_BOOL, propVal);
}

BOOL IFeatCmd::GetBound()
{
	BOOL result;
	GetProperty(0x4d, VT_BOOL, (void*)&result);
	return result;
}

void IFeatCmd::SetBound(BOOL propVal)
{
	SetProperty(0x4d, VT_BOOL, propVal);
}

BOOL IFeatCmd::GetDisplayConeAngle()
{
	BOOL result;
	GetProperty(0x4e, VT_BOOL, (void*)&result);
	return result;
}

void IFeatCmd::SetDisplayConeAngle(BOOL propVal)
{
	SetProperty(0x4e, VT_BOOL, propVal);
}

BOOL IFeatCmd::GetLine3D()
{
	BOOL result;
	GetProperty(0x4f, VT_BOOL, (void*)&result);
	return result;
}

void IFeatCmd::SetLine3D(BOOL propVal)
{
	SetProperty(0x4f, VT_BOOL, propVal);
}

BOOL IFeatCmd::GetDCCMeasureInMasterMode()
{
	BOOL result;
	GetProperty(0x50, VT_BOOL, (void*)&result);
	return result;
}

void IFeatCmd::SetDCCMeasureInMasterMode(BOOL propVal)
{
	SetProperty(0x50, VT_BOOL, propVal);
}

BOOL IFeatCmd::GetDCCFindNomsMode()
{
	BOOL result;
	GetProperty(0x51, VT_BOOL, (void*)&result);
	return result;
}

void IFeatCmd::SetDCCFindNomsMode(BOOL propVal)
{
	SetProperty(0x51, VT_BOOL, propVal);
}

BOOL IFeatCmd::GetInteriorHit()
{
	BOOL result;
	GetProperty(0x52, VT_BOOL, (void*)&result);
	return result;
}

void IFeatCmd::SetInteriorHit(BOOL propVal)
{
	SetProperty(0x52, VT_BOOL, propVal);
}

BOOL IFeatCmd::GetAutoPH9()
{
	BOOL result;
	GetProperty(0x53, VT_BOOL, (void*)&result);
	return result;
}

void IFeatCmd::SetAutoPH9(BOOL propVal)
{
	SetProperty(0x53, VT_BOOL, propVal);
}

BOOL IFeatCmd::GetAutoClearPlane()
{
	BOOL result;
	GetProperty(0x54, VT_BOOL, (void*)&result);
	return result;
}

void IFeatCmd::SetAutoClearPlane(BOOL propVal)
{
	SetProperty(0x54, VT_BOOL, propVal);
}

BOOL IFeatCmd::GetAutoCircularMove()
{
	BOOL result;
	GetProperty(0x55, VT_BOOL, (void*)&result);
	return result;
}

void IFeatCmd::SetAutoCircularMove(BOOL propVal)
{
	SetProperty(0x55, VT_BOOL, propVal);
}

long IFeatCmd::GetReferenceType()
{
	long result;
	GetProperty(0x56, VT_I4, (void*)&result);
	return result;
}

void IFeatCmd::SetReferenceType(long propVal)
{
	SetProperty(0x56, VT_I4, propVal);
}

CString IFeatCmd::GetReferenceID()
{
	CString result;
	GetProperty(0x57, VT_BSTR, (void*)&result);
	return result;
}

void IFeatCmd::SetReferenceID(LPCTSTR propVal)
{
	SetProperty(0x57, VT_BSTR, propVal);
}

long IFeatCmd::GetBestFitMathType()
{
	long result;
	GetProperty(0x58, VT_I4, (void*)&result);
	return result;
}

void IFeatCmd::SetBestFitMathType(long propVal)
{
	SetProperty(0x58, VT_I4, propVal);
}

BOOL IFeatCmd::GetUseTheoValuesForBestfit()
{
	BOOL result;
	GetProperty(0x5c, VT_BOOL, (void*)&result);
	return result;
}

void IFeatCmd::SetUseTheoValuesForBestfit(BOOL propVal)
{
	SetProperty(0x5c, VT_BOOL, propVal);
}

double IFeatCmd::GetVisionMag()
{
	double result;
	GetProperty(0x5e, VT_R8, (void*)&result);
	return result;
}

void IFeatCmd::SetVisionMag(double propVal)
{
	SetProperty(0x5e, VT_R8, propVal);
}

long IFeatCmd::GetVisionTargetColor()
{
	long result;
	GetProperty(0x5f, VT_I4, (void*)&result);
	return result;
}

void IFeatCmd::SetVisionTargetColor(long propVal)
{
	SetProperty(0x5f, VT_I4, propVal);
}

BOOL IFeatCmd::GetManualPrePosition()
{
	BOOL result;
	GetProperty(0x60, VT_BOOL, (void*)&result);
	return result;
}

void IFeatCmd::SetManualPrePosition(BOOL propVal)
{
	SetProperty(0x60, VT_BOOL, propVal);
}

long IFeatCmd::GetVisionTargetType()
{
	long result;
	GetProperty(0x61, VT_I4, (void*)&result);
	return result;
}

void IFeatCmd::SetVisionTargetType(long propVal)
{
	SetProperty(0x61, VT_I4, propVal);
}

LPDISPATCH IFeatCmd::GetTargets()
{
	LPDISPATCH result;
	GetProperty(0x62, VT_DISPATCH, (void*)&result);
	return result;
}

void IFeatCmd::SetTargets(LPDISPATCH propVal)
{
	SetProperty(0x62, VT_DISPATCH, propVal);
}

BOOL IFeatCmd::GetHasUserDefinedHits()
{
	BOOL result;
	GetProperty(0x68, VT_BOOL, (void*)&result);
	return result;
}

void IFeatCmd::SetHasUserDefinedHits(BOOL propVal)
{
	SetProperty(0x68, VT_BOOL, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IFeatCmd operations

BOOL IFeatCmd::GenerateHits()
{
	BOOL result;
	InvokeHelper(0x3a, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
	return result;
}

BOOL IFeatCmd::GetData(LPDISPATCH* PointData, long DataType, long TheoMeas, long CoordSystem, LPCTSTR AlignID, long Workplane)
{
	BOOL result;
	static BYTE parms[] =
		VTS_PDISPATCH VTS_I4 VTS_I4 VTS_I4 VTS_BSTR VTS_I4;
	InvokeHelper(0x3b, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		PointData, DataType, TheoMeas, CoordSystem, AlignID, Workplane);
	return result;
}

BOOL IFeatCmd::PutData(LPDISPATCH* Data, long DataType, long TheoMeas, long CoordSystem, LPCTSTR AlignID, long Workplane)
{
	BOOL result;
	static BYTE parms[] =
		VTS_PDISPATCH VTS_I4 VTS_I4 VTS_I4 VTS_BSTR VTS_I4;
	InvokeHelper(0x3c, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		Data, DataType, TheoMeas, CoordSystem, AlignID, Workplane);
	return result;
}

BOOL IFeatCmd::SetInputFeat(LPCTSTR ID, long index)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR VTS_I4;
	InvokeHelper(0x3d, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		ID, index);
	return result;
}

BOOL IFeatCmd::RemoveInputFeat(long index)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x3e, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		index);
	return result;
}

BOOL IFeatCmd::AddInputFeat(LPCTSTR ID)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x3f, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		ID);
	return result;
}

CString IFeatCmd::GetInputID(long index)
{
	CString result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x40, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
		index);
	return result;
}

LPDISPATCH IFeatCmd::GetHit(long index, long DataType, long MeasOrTheo, long CoordSystem, LPCTSTR Alignment, long Workplane)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_BSTR VTS_I4;
	InvokeHelper(0x41, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		index, DataType, MeasOrTheo, CoordSystem, Alignment, Workplane);
	return result;
}

BOOL IFeatCmd::GetVector(long VectorType, long TheoMeas, double* I, double* J, double* K)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_PR8 VTS_PR8 VTS_PR8;
	InvokeHelper(0x42, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		VectorType, TheoMeas, I, J, K);
	return result;
}

BOOL IFeatCmd::GetPoint(long PointType, long TheoMeas, double* X, double* Y, double* Z)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_PR8 VTS_PR8 VTS_PR8;
	InvokeHelper(0x43, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		PointType, TheoMeas, X, Y, Z);
	return result;
}

BOOL IFeatCmd::PutVector(long VectorType, long TheoMeas, double I, double J, double K)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0x44, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		VectorType, TheoMeas, I, J, K);
	return result;
}

BOOL IFeatCmd::PutPoint(long PointType, long TheoMeas, double X, double Y, double Z)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0x45, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		PointType, TheoMeas, X, Y, Z);
	return result;
}

BOOL IFeatCmd::GetSurfaceVectors(long TheoMeas, double* I1, double* J1, double* K1, double* I2, double* J2, double* K2)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4 VTS_PR8 VTS_PR8 VTS_PR8 VTS_PR8 VTS_PR8 VTS_PR8;
	InvokeHelper(0x46, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		TheoMeas, I1, J1, K1, I2, J2, K2);
	return result;
}

BOOL IFeatCmd::PutSurfaceVectors(long TheoMeas, double I1, double J1, double K1, double I2, double J2, double K2)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4 VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0x47, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		TheoMeas, I1, J1, K1, I2, J2, K2);
	return result;
}

double IFeatCmd::GetInputOffset(long index)
{
	double result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x48, DISPATCH_METHOD, VT_R8, (void*)&result, parms,
		index);
	return result;
}

BOOL IFeatCmd::SetInputOffset(long index, double Offset)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4 VTS_R8;
	InvokeHelper(0x49, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		index, Offset);
	return result;
}

BOOL IFeatCmd::CalculateNominals()
{
	BOOL result;
	InvokeHelper(0x4a, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
	return result;
}

BOOL IFeatCmd::CountHits()
{
	BOOL result;
	InvokeHelper(0x4b, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
	return result;
}

BOOL IFeatCmd::SetHit(long index, long DataType, long MeasOrTheo, double X, double Y, double Z)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_I4 VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0x59, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		index, DataType, MeasOrTheo, X, Y, Z);
	return result;
}

BOOL IFeatCmd::SetHit2(long index, long DataType, long MeasOrTheo, long CoordSystem, LPCTSTR Alignment, long Workplane, double X, double Y, double Z)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_BSTR VTS_I4 VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0x5a, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		index, DataType, MeasOrTheo, CoordSystem, Alignment, Workplane, X, Y, Z);
	return result;
}

BOOL IFeatCmd::Evaluate(long MeasNominal)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x5b, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		MeasNominal);
	return result;
}

LPDISPATCH IFeatCmd::GetSampleHit(long index, long DataType, long MeasOrTheo, long CoordSystem, LPCTSTR Alignment, long Workplane)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_BSTR VTS_I4;
	InvokeHelper(0x63, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		index, DataType, MeasOrTheo, CoordSystem, Alignment, Workplane);
	return result;
}

LPDISPATCH IFeatCmd::GetCircMoveItem(long CircMove_Index, long Move_index, long CoordSystem, LPCTSTR Alignment, long Workplane)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_I4 VTS_BSTR VTS_I4;
	InvokeHelper(0x64, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		CircMove_Index, Move_index, CoordSystem, Alignment, Workplane);
	return result;
}

double IFeatCmd::GetFormError()
{
	double result;
	InvokeHelper(0x65, DISPATCH_METHOD, VT_R8, (void*)&result, NULL);
	return result;
}

VARIANT IFeatCmd::GetPoints(long DataType, long MeasOrTheo, long CoordSystem, LPCTSTR Alignment, long Workplane)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_I4 VTS_BSTR VTS_I4;
	InvokeHelper(0x66, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		DataType, MeasOrTheo, CoordSystem, Alignment, Workplane);
	return result;
}

long IFeatCmd::AddInputFeatures(const VARIANT& IDs)
{
	long result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x67, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		&IDs);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ITargets properties

long ITargets::GetCount()
{
	long result;
	GetProperty(0x1, VT_I4, (void*)&result);
	return result;
}

void ITargets::SetCount(long propVal)
{
	SetProperty(0x1, VT_I4, propVal);
}

LPDISPATCH ITargets::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x2, VT_DISPATCH, (void*)&result);
	return result;
}

void ITargets::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x2, VT_DISPATCH, propVal);
}

LPDISPATCH ITargets::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x3, VT_DISPATCH, (void*)&result);
	return result;
}

void ITargets::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x3, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// ITargets operations

LPDISPATCH ITargets::Item(long Num)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Num);
	return result;
}

void ITargets::Remove(long Num)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Num);
}

void ITargets::Add(double a, double b)
{
	static BYTE parms[] =
		VTS_R8 VTS_R8;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 a, b);
}

LPDISPATCH ITargets::_Item(long Num)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Num);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ITarget properties

long ITarget::GetStrength()
{
	long result;
	GetProperty(0x1, VT_I4, (void*)&result);
	return result;
}

void ITarget::SetStrength(long propVal)
{
	SetProperty(0x1, VT_I4, propVal);
}

long ITarget::GetEdgeSelectionType()
{
	long result;
	GetProperty(0x2, VT_I4, (void*)&result);
	return result;
}

void ITarget::SetEdgeSelectionType(long propVal)
{
	SetProperty(0x2, VT_I4, propVal);
}

long ITarget::GetFocus()
{
	long result;
	GetProperty(0x3, VT_I4, (void*)&result);
	return result;
}

void ITarget::SetFocus(long propVal)
{
	SetProperty(0x3, VT_I4, propVal);
}

long ITarget::GetFocusRange()
{
	long result;
	GetProperty(0x4, VT_I4, (void*)&result);
	return result;
}

void ITarget::SetFocusRange(long propVal)
{
	SetProperty(0x4, VT_I4, propVal);
}

long ITarget::GetFocusDuration()
{
	long result;
	GetProperty(0x5, VT_I4, (void*)&result);
	return result;
}

void ITarget::SetFocusDuration(long propVal)
{
	SetProperty(0x5, VT_I4, propVal);
}

long ITarget::GetFocusHiAccuracy()
{
	long result;
	GetProperty(0x6, VT_I4, (void*)&result);
	return result;
}

void ITarget::SetFocusHiAccuracy(long propVal)
{
	SetProperty(0x6, VT_I4, propVal);
}

long ITarget::GetPointDensityType()
{
	long result;
	GetProperty(0x7, VT_I4, (void*)&result);
	return result;
}

void ITarget::SetPointDensityType(long propVal)
{
	SetProperty(0x7, VT_I4, propVal);
}

long ITarget::GetEdgeSelectionSpecifiedNum()
{
	long result;
	GetProperty(0x8, VT_I4, (void*)&result);
	return result;
}

void ITarget::SetEdgeSelectionSpecifiedNum(long propVal)
{
	SetProperty(0x8, VT_I4, propVal);
}

long ITarget::GetEdgeScanDirection()
{
	long result;
	GetProperty(0x9, VT_I4, (void*)&result);
	return result;
}

void ITarget::SetEdgeScanDirection(long propVal)
{
	SetProperty(0x9, VT_I4, propVal);
}

double ITarget::GetCrossHairSize()
{
	double result;
	GetProperty(0xa, VT_R8, (void*)&result);
	return result;
}

void ITarget::SetCrossHairSize(double propVal)
{
	SetProperty(0xa, VT_R8, propVal);
}

long ITarget::GetOutlierFilter()
{
	long result;
	GetProperty(0xb, VT_I4, (void*)&result);
	return result;
}

void ITarget::SetOutlierFilter(long propVal)
{
	SetProperty(0xb, VT_I4, propVal);
}

double ITarget::GetOutlierFilterDistanceThreshold()
{
	double result;
	GetProperty(0xc, VT_R8, (void*)&result);
	return result;
}

void ITarget::SetOutlierFilterDistanceThreshold(double propVal)
{
	SetProperty(0xc, VT_R8, propVal);
}

double ITarget::GetOutlierFilterStdDevThreshold()
{
	double result;
	GetProperty(0xd, VT_R8, (void*)&result);
	return result;
}

void ITarget::SetOutlierFilterStdDevThreshold(double propVal)
{
	SetProperty(0xd, VT_R8, propVal);
}

long ITarget::GetOutlierFilterUsingNeighbors()
{
	long result;
	GetProperty(0xe, VT_I4, (void*)&result);
	return result;
}

void ITarget::SetOutlierFilterUsingNeighbors(long propVal)
{
	SetProperty(0xe, VT_I4, propVal);
}

long ITarget::GetOutlierFilterMinNeighbors()
{
	long result;
	GetProperty(0xf, VT_I4, (void*)&result);
	return result;
}

void ITarget::SetOutlierFilterMinNeighbors(long propVal)
{
	SetProperty(0xf, VT_I4, propVal);
}

double ITarget::GetOutlierFilterNeighborDistanceMultiplier()
{
	double result;
	GetProperty(0x10, VT_R8, (void*)&result);
	return result;
}

void ITarget::SetOutlierFilterNeighborDistanceMultiplier(double propVal)
{
	SetProperty(0x10, VT_R8, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// ITarget operations


/////////////////////////////////////////////////////////////////////////////
// IModalCmd properties

long IModalCmd::GetClearPlane()
{
	long result;
	GetProperty(0x1, VT_I4, (void*)&result);
	return result;
}

void IModalCmd::SetClearPlane(long propVal)
{
	SetProperty(0x1, VT_I4, propVal);
}

long IModalCmd::GetDigits()
{
	long result;
	GetProperty(0x2, VT_I4, (void*)&result);
	return result;
}

void IModalCmd::SetDigits(long propVal)
{
	SetProperty(0x2, VT_I4, propVal);
}

double IModalCmd::GetDistance()
{
	double result;
	GetProperty(0x3, VT_R8, (void*)&result);
	return result;
}

void IModalCmd::SetDistance(double propVal)
{
	SetProperty(0x3, VT_R8, propVal);
}

double IModalCmd::GetDistance2()
{
	double result;
	GetProperty(0x4, VT_R8, (void*)&result);
	return result;
}

void IModalCmd::SetDistance2(double propVal)
{
	SetProperty(0x4, VT_R8, propVal);
}

BOOL IModalCmd::GetOn()
{
	BOOL result;
	GetProperty(0x5, VT_BOOL, (void*)&result);
	return result;
}

void IModalCmd::SetOn(BOOL propVal)
{
	SetProperty(0x5, VT_BOOL, propVal);
}

LPDISPATCH IModalCmd::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x6, VT_DISPATCH, (void*)&result);
	return result;
}

void IModalCmd::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x6, VT_DISPATCH, propVal);
}

long IModalCmd::GetPassPlane()
{
	long result;
	GetProperty(0x7, VT_I4, (void*)&result);
	return result;
}

void IModalCmd::SetPassPlane(long propVal)
{
	SetProperty(0x7, VT_I4, propVal);
}

double IModalCmd::GetSpeed()
{
	double result;
	GetProperty(0x8, VT_R8, (void*)&result);
	return result;
}

void IModalCmd::SetSpeed(double propVal)
{
	SetProperty(0x8, VT_R8, propVal);
}

long IModalCmd::GetWorkplane()
{
	long result;
	GetProperty(0x9, VT_I4, (void*)&result);
	return result;
}

void IModalCmd::SetWorkplane(long propVal)
{
	SetProperty(0x9, VT_I4, propVal);
}

CString IModalCmd::GetName()
{
	CString result;
	GetProperty(0xa, VT_BSTR, (void*)&result);
	return result;
}

void IModalCmd::SetName(LPCTSTR propVal)
{
	SetProperty(0xa, VT_BSTR, propVal);
}

long IModalCmd::GetManDCCMode()
{
	long result;
	GetProperty(0xb, VT_I4, (void*)&result);
	return result;
}

void IModalCmd::SetManDCCMode(long propVal)
{
	SetProperty(0xb, VT_I4, propVal);
}

long IModalCmd::GetRMeasMode()
{
	long result;
	GetProperty(0xc, VT_I4, (void*)&result);
	return result;
}

void IModalCmd::SetRMeasMode(long propVal)
{
	SetProperty(0xc, VT_I4, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IModalCmd operations


/////////////////////////////////////////////////////////////////////////////
// IMoveCmd properties

double IMoveCmd::GetAngle()
{
	double result;
	GetProperty(0x1, VT_R8, (void*)&result);
	return result;
}

void IMoveCmd::SetAngle(double propVal)
{
	SetProperty(0x1, VT_R8, propVal);
}

long IMoveCmd::GetDirection()
{
	long result;
	GetProperty(0x2, VT_I4, (void*)&result);
	return result;
}

void IMoveCmd::SetDirection(long propVal)
{
	SetProperty(0x2, VT_I4, propVal);
}

LPDISPATCH IMoveCmd::GetXyz()
{
	LPDISPATCH result;
	GetProperty(0x3, VT_DISPATCH, (void*)&result);
	return result;
}

void IMoveCmd::SetXyz(LPDISPATCH propVal)
{
	SetProperty(0x3, VT_DISPATCH, propVal);
}

LPDISPATCH IMoveCmd::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x4, VT_DISPATCH, (void*)&result);
	return result;
}

void IMoveCmd::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x4, VT_DISPATCH, propVal);
}

CString IMoveCmd::GetOldTip()
{
	CString result;
	GetProperty(0x5, VT_BSTR, (void*)&result);
	return result;
}

void IMoveCmd::SetOldTip(LPCTSTR propVal)
{
	SetProperty(0x5, VT_BSTR, propVal);
}

CString IMoveCmd::GetNewTip()
{
	CString result;
	GetProperty(0x6, VT_BSTR, (void*)&result);
	return result;
}

void IMoveCmd::SetNewTip(LPCTSTR propVal)
{
	SetProperty(0x6, VT_BSTR, propVal);
}

LPDISPATCH IMoveCmd::GetIjk()
{
	LPDISPATCH result;
	GetProperty(0x7, VT_DISPATCH, (void*)&result);
	return result;
}

void IMoveCmd::SetIjk(LPDISPATCH propVal)
{
	SetProperty(0x7, VT_DISPATCH, propVal);
}

LPDISPATCH IMoveCmd::GetXYZStart()
{
	LPDISPATCH result;
	GetProperty(0x8, VT_DISPATCH, (void*)&result);
	return result;
}

void IMoveCmd::SetXYZStart(LPDISPATCH propVal)
{
	SetProperty(0x8, VT_DISPATCH, propVal);
}

LPDISPATCH IMoveCmd::GetXYZEnd()
{
	LPDISPATCH result;
	GetProperty(0x9, VT_DISPATCH, (void*)&result);
	return result;
}

void IMoveCmd::SetXYZEnd(LPDISPATCH propVal)
{
	SetProperty(0x9, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IMoveCmd operations


/////////////////////////////////////////////////////////////////////////////
// IFlowControlCmd properties

double IFlowControlCmd::GetAngleOffset()
{
	double result;
	GetProperty(0x1, VT_R8, (void*)&result);
	return result;
}

void IFlowControlCmd::SetAngleOffset(double propVal)
{
	SetProperty(0x1, VT_R8, propVal);
}

long IFlowControlCmd::GetEndNum()
{
	long result;
	GetProperty(0x2, VT_I4, (void*)&result);
	return result;
}

void IFlowControlCmd::SetEndNum(long propVal)
{
	SetProperty(0x2, VT_I4, propVal);
}

long IFlowControlCmd::GetErrorMode()
{
	long result;
	GetProperty(0x3, VT_I4, (void*)&result);
	return result;
}

void IFlowControlCmd::SetErrorMode(long propVal)
{
	SetProperty(0x3, VT_I4, propVal);
}

long IFlowControlCmd::GetErrorType()
{
	long result;
	GetProperty(0x4, VT_I4, (void*)&result);
	return result;
}

void IFlowControlCmd::SetErrorType(long propVal)
{
	SetProperty(0x4, VT_I4, propVal);
}

CString IFlowControlCmd::GetFilename()
{
	CString result;
	GetProperty(0x5, VT_BSTR, (void*)&result);
	return result;
}

void IFlowControlCmd::SetFilename(LPCTSTR propVal)
{
	SetProperty(0x5, VT_BSTR, propVal);
}

CString IFlowControlCmd::GetId()
{
	CString result;
	GetProperty(0x6, VT_BSTR, (void*)&result);
	return result;
}

void IFlowControlCmd::SetId(LPCTSTR propVal)
{
	SetProperty(0x6, VT_BSTR, propVal);
}

CString IFlowControlCmd::GetLabel()
{
	CString result;
	GetProperty(0x7, VT_BSTR, (void*)&result);
	return result;
}

void IFlowControlCmd::SetLabel(LPCTSTR propVal)
{
	SetProperty(0x7, VT_BSTR, propVal);
}

long IFlowControlCmd::GetNumArguments()
{
	long result;
	GetProperty(0x8, VT_I4, (void*)&result);
	return result;
}

void IFlowControlCmd::SetNumArguments(long propVal)
{
	SetProperty(0x8, VT_I4, propVal);
}

long IFlowControlCmd::GetSkipCount()
{
	long result;
	GetProperty(0x9, VT_I4, (void*)&result);
	return result;
}

void IFlowControlCmd::SetSkipCount(long propVal)
{
	SetProperty(0x9, VT_I4, propVal);
}

long IFlowControlCmd::GetStartNum()
{
	long result;
	GetProperty(0xa, VT_I4, (void*)&result);
	return result;
}

void IFlowControlCmd::SetStartNum(long propVal)
{
	SetProperty(0xa, VT_I4, propVal);
}

CString IFlowControlCmd::GetSubName()
{
	CString result;
	GetProperty(0xb, VT_BSTR, (void*)&result);
	return result;
}

void IFlowControlCmd::SetSubName(LPCTSTR propVal)
{
	SetProperty(0xb, VT_BSTR, propVal);
}

double IFlowControlCmd::GetXAxisOffset()
{
	double result;
	GetProperty(0xc, VT_R8, (void*)&result);
	return result;
}

void IFlowControlCmd::SetXAxisOffset(double propVal)
{
	SetProperty(0xc, VT_R8, propVal);
}

double IFlowControlCmd::GetYAxisOffset()
{
	double result;
	GetProperty(0xd, VT_R8, (void*)&result);
	return result;
}

void IFlowControlCmd::SetYAxisOffset(double propVal)
{
	SetProperty(0xd, VT_R8, propVal);
}

double IFlowControlCmd::GetZAxisOffset()
{
	double result;
	GetProperty(0xe, VT_R8, (void*)&result);
	return result;
}

void IFlowControlCmd::SetZAxisOffset(double propVal)
{
	SetProperty(0xe, VT_R8, propVal);
}

CString IFlowControlCmd::GetExpression()
{
	CString result;
	GetProperty(0xf, VT_BSTR, (void*)&result);
	return result;
}

void IFlowControlCmd::SetExpression(LPCTSTR propVal)
{
	SetProperty(0xf, VT_BSTR, propVal);
}

BOOL IFlowControlCmd::GetReportAutoPrint()
{
	BOOL result;
	GetProperty(0x10, VT_BOOL, (void*)&result);
	return result;
}

void IFlowControlCmd::SetReportAutoPrint(BOOL propVal)
{
	SetProperty(0x10, VT_BOOL, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IFlowControlCmd operations

BOOL IFlowControlCmd::AddArgument(long Position, LPCTSTR Argument, LPCTSTR Name, LPCTSTR DESCRIPTION)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4 VTS_BSTR VTS_BSTR VTS_BSTR;
	InvokeHelper(0x11, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		Position, Argument, Name, DESCRIPTION);
	return result;
}

BOOL IFlowControlCmd::AddSkipNum(long Number)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x12, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		Number);
	return result;
}

CString IFlowControlCmd::GetArgumentName(long Position)
{
	CString result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x13, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
		Position);
	return result;
}

BOOL IFlowControlCmd::SetArgumentName(long Position, LPCTSTR Name)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4 VTS_BSTR;
	InvokeHelper(0x14, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		Position, Name);
	return result;
}

CString IFlowControlCmd::GetArgumentDescription(long Position)
{
	CString result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x15, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
		Position);
	return result;
}

BOOL IFlowControlCmd::SetArgumentDescription(long Position, LPCTSTR DESCRIPTION)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4 VTS_BSTR;
	InvokeHelper(0x16, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		Position, DESCRIPTION);
	return result;
}

CString IFlowControlCmd::GetArgumentExpression(long Position)
{
	CString result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x17, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
		Position);
	return result;
}

BOOL IFlowControlCmd::SetArgumentExpression(long Position, LPCTSTR Expression)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4 VTS_BSTR;
	InvokeHelper(0x18, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		Position, Expression);
	return result;
}

BOOL IFlowControlCmd::IsExpressionValid(LPCTSTR Expression)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x19, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		Expression);
	return result;
}

BOOL IFlowControlCmd::RemoveArgument(long Position)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x1a, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		Position);
	return result;
}

long IFlowControlCmd::GetSkipNum(long index)
{
	long result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x1b, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		index);
	return result;
}

BOOL IFlowControlCmd::RemoveSkipNum(long index)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x1c, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		index);
	return result;
}

void IFlowControlCmd::SetRightSideOfAssignment(LPCTSTR Expression)
{
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x1d, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Expression);
}

void IFlowControlCmd::SetLeftSideOfAssignment(LPCTSTR Expression)
{
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x1e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Expression);
}

BOOL IFlowControlCmd::IsValidLeftHandValue(LPCTSTR Expression)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x1f, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		Expression);
	return result;
}

BOOL IFlowControlCmd::IsValidSubroutineArgumentName(LPCTSTR Expression)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x20, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		Expression);
	return result;
}

CString IFlowControlCmd::GetLeftSideOfExpression()
{
	CString result;
	InvokeHelper(0x21, DISPATCH_METHOD, VT_BSTR, (void*)&result, NULL);
	return result;
}

CString IFlowControlCmd::GetRightSideOfExpression()
{
	CString result;
	InvokeHelper(0x22, DISPATCH_METHOD, VT_BSTR, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IBasicScan properties

long IBasicScan::GetMethod()
{
	long result;
	GetProperty(0x1, VT_I4, (void*)&result);
	return result;
}

void IBasicScan::SetMethod(long propVal)
{
	SetProperty(0x1, VT_I4, propVal);
}

long IBasicScan::GetFilter()
{
	long result;
	GetProperty(0x2, VT_I4, (void*)&result);
	return result;
}

void IBasicScan::SetFilter(long propVal)
{
	SetProperty(0x2, VT_I4, propVal);
}

long IBasicScan::GetOperationMode()
{
	long result;
	GetProperty(0x3, VT_I4, (void*)&result);
	return result;
}

void IBasicScan::SetOperationMode(long propVal)
{
	SetProperty(0x3, VT_I4, propVal);
}

long IBasicScan::GetHitType()
{
	long result;
	GetProperty(0x4, VT_I4, (void*)&result);
	return result;
}

void IBasicScan::SetHitType(long propVal)
{
	SetProperty(0x4, VT_I4, propVal);
}

long IBasicScan::GetNominalMode()
{
	long result;
	GetProperty(0x5, VT_I4, (void*)&result);
	return result;
}

void IBasicScan::SetNominalMode(long propVal)
{
	SetProperty(0x5, VT_I4, propVal);
}

long IBasicScan::GetBoundaryCondition()
{
	long result;
	GetProperty(0x6, VT_I4, (void*)&result);
	return result;
}

void IBasicScan::SetBoundaryCondition(long propVal)
{
	SetProperty(0x6, VT_I4, propVal);
}

LPDISPATCH IBasicScan::GetMethodStart()
{
	LPDISPATCH result;
	GetProperty(0x7, VT_DISPATCH, (void*)&result);
	return result;
}

void IBasicScan::SetMethodStart(LPDISPATCH propVal)
{
	SetProperty(0x7, VT_DISPATCH, propVal);
}

LPDISPATCH IBasicScan::GetMethodEnd()
{
	LPDISPATCH result;
	GetProperty(0x8, VT_DISPATCH, (void*)&result);
	return result;
}

void IBasicScan::SetMethodEnd(LPDISPATCH propVal)
{
	SetProperty(0x8, VT_DISPATCH, propVal);
}

LPDISPATCH IBasicScan::GetMethodInitTouch()
{
	LPDISPATCH result;
	GetProperty(0x9, VT_DISPATCH, (void*)&result);
	return result;
}

void IBasicScan::SetMethodInitTouch(LPDISPATCH propVal)
{
	SetProperty(0x9, VT_DISPATCH, propVal);
}

LPDISPATCH IBasicScan::GetMethodEndTouch()
{
	LPDISPATCH result;
	GetProperty(0xa, VT_DISPATCH, (void*)&result);
	return result;
}

void IBasicScan::SetMethodEndTouch(LPDISPATCH propVal)
{
	SetProperty(0xa, VT_DISPATCH, propVal);
}

LPDISPATCH IBasicScan::GetMethodInitDir()
{
	LPDISPATCH result;
	GetProperty(0xb, VT_DISPATCH, (void*)&result);
	return result;
}

void IBasicScan::SetMethodInitDir(LPDISPATCH propVal)
{
	SetProperty(0xb, VT_DISPATCH, propVal);
}

LPDISPATCH IBasicScan::GetMethodInitTopSurf()
{
	LPDISPATCH result;
	GetProperty(0xc, VT_DISPATCH, (void*)&result);
	return result;
}

void IBasicScan::SetMethodInitTopSurf(LPDISPATCH propVal)
{
	SetProperty(0xc, VT_DISPATCH, propVal);
}

LPDISPATCH IBasicScan::GetMethodCutPlane()
{
	LPDISPATCH result;
	GetProperty(0xd, VT_DISPATCH, (void*)&result);
	return result;
}

void IBasicScan::SetMethodCutPlane(LPDISPATCH propVal)
{
	SetProperty(0xd, VT_DISPATCH, propVal);
}

LPDISPATCH IBasicScan::GetBoundaryConditionCenter()
{
	LPDISPATCH result;
	GetProperty(0xe, VT_DISPATCH, (void*)&result);
	return result;
}

void IBasicScan::SetBoundaryConditionCenter(LPDISPATCH propVal)
{
	SetProperty(0xe, VT_DISPATCH, propVal);
}

LPDISPATCH IBasicScan::GetBoundaryConditionPlaneV()
{
	LPDISPATCH result;
	GetProperty(0xf, VT_DISPATCH, (void*)&result);
	return result;
}

void IBasicScan::SetBoundaryConditionPlaneV(LPDISPATCH propVal)
{
	SetProperty(0xf, VT_DISPATCH, propVal);
}

LPDISPATCH IBasicScan::GetBoundaryConditionAxisV()
{
	LPDISPATCH result;
	GetProperty(0x10, VT_DISPATCH, (void*)&result);
	return result;
}

void IBasicScan::SetBoundaryConditionAxisV(LPDISPATCH propVal)
{
	SetProperty(0x10, VT_DISPATCH, propVal);
}

LPDISPATCH IBasicScan::GetBoundaryConditionEndApproach()
{
	LPDISPATCH result;
	GetProperty(0x11, VT_DISPATCH, (void*)&result);
	return result;
}

void IBasicScan::SetBoundaryConditionEndApproach(LPDISPATCH propVal)
{
	SetProperty(0x11, VT_DISPATCH, propVal);
}

BOOL IBasicScan::GetSinglePoint()
{
	BOOL result;
	GetProperty(0x27, VT_BOOL, (void*)&result);
	return result;
}

void IBasicScan::SetSinglePoint(BOOL propVal)
{
	SetProperty(0x27, VT_BOOL, propVal);
}

BOOL IBasicScan::GetAutoClearPlane()
{
	BOOL result;
	GetProperty(0x28, VT_BOOL, (void*)&result);
	return result;
}

void IBasicScan::SetAutoClearPlane(BOOL propVal)
{
	SetProperty(0x28, VT_BOOL, propVal);
}

BOOL IBasicScan::GetDisplayHits()
{
	BOOL result;
	GetProperty(0x29, VT_BOOL, (void*)&result);
	return result;
}

void IBasicScan::SetDisplayHits(BOOL propVal)
{
	SetProperty(0x29, VT_BOOL, propVal);
}

long IBasicScan::GetBoundaryPointCount()
{
	long result;
	GetProperty(0x2a, VT_I4, (void*)&result);
	return result;
}

void IBasicScan::SetBoundaryPointCount(long propVal)
{
	SetProperty(0x2a, VT_I4, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IBasicScan operations

BOOL IBasicScan::SetMethodParams(long bIn, BOOL bCenteringType, long nCenteringDirection, double dDiameter, double dArcAngle, double dDepth, double dPitch)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4 VTS_BOOL VTS_I4 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0x12, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		bIn, bCenteringType, nCenteringDirection, dDiameter, dArcAngle, dDepth, dPitch);
	return result;
}

BOOL IBasicScan::GetMethodParams(long* bIn, BOOL* bCenteringType, long* nCenteringDirection, double* dDiameter, double* dArcAngle, double* dDepth, double* dPitch)
{
	BOOL result;
	static BYTE parms[] =
		VTS_PI4 VTS_PBOOL VTS_PI4 VTS_PR8 VTS_PR8 VTS_PR8 VTS_PR8;
	InvokeHelper(0x13, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		bIn, bCenteringType, nCenteringDirection, dDiameter, dArcAngle, dDepth, dPitch);
	return result;
}

BOOL IBasicScan::GetBoundaryConditionParams(long* nCrossings, double* dRadius, double* dHalfAngle)
{
	BOOL result;
	static BYTE parms[] =
		VTS_PI4 VTS_PR8 VTS_PR8;
	InvokeHelper(0x14, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		nCrossings, dRadius, dHalfAngle);
	return result;
}

BOOL IBasicScan::SetBoundaryConditionParams(long nCrossings, double dRadius, double dHalfAngle)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4 VTS_R8 VTS_R8;
	InvokeHelper(0x15, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		nCrossings, dRadius, dHalfAngle);
	return result;
}

BOOL IBasicScan::SetNomsParams(double dFindNomsTolerance, double dSurfaceThickness, double dEdgeThickness)
{
	BOOL result;
	static BYTE parms[] =
		VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0x16, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		dFindNomsTolerance, dSurfaceThickness, dEdgeThickness);
	return result;
}

BOOL IBasicScan::GetNomsParams(double* dFindNomsTolerance, double* dSurfaceThickness, double* dEdgeThickness)
{
	BOOL result;
	static BYTE parms[] =
		VTS_PR8 VTS_PR8 VTS_PR8;
	InvokeHelper(0x17, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		dFindNomsTolerance, dSurfaceThickness, dEdgeThickness);
	return result;
}

BOOL IBasicScan::SetFilterParams(double dCutAxisLocation, long nAxis, double dMaxIncrement, double dMinIncrement, double dMaxAngle, double dMinAngle)
{
	BOOL result;
	static BYTE parms[] =
		VTS_R8 VTS_I4 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0x18, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		dCutAxisLocation, nAxis, dMaxIncrement, dMinIncrement, dMaxAngle, dMinAngle);
	return result;
}

BOOL IBasicScan::SetHitParams(long nInitSamples, long nPermSamples, double dSpacer, double dIndent, double dDepth)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0x19, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		nInitSamples, nPermSamples, dSpacer, dIndent, dDepth);
	return result;
}

BOOL IBasicScan::GetHitParams(long* nInitSamples, long* nPermSamples, double* dSpacer, double* dIndent, double* dDepth)
{
	BOOL result;
	static BYTE parms[] =
		VTS_PI4 VTS_PI4 VTS_PR8 VTS_PR8 VTS_PR8;
	InvokeHelper(0x1a, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		nInitSamples, nPermSamples, dSpacer, dIndent, dDepth);
	return result;
}

BOOL IBasicScan::GetFilterParams(double* dCutAxisLocation, long* nAxis, double* dMaxIncrement, double* dMinIncrement, double* dMaxAngle, double* dMinAngle)
{
	BOOL result;
	static BYTE parms[] =
		VTS_PR8 VTS_PI4 VTS_PR8 VTS_PR8 VTS_PR8 VTS_PR8;
	InvokeHelper(0x1b, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		dCutAxisLocation, nAxis, dMaxIncrement, dMinIncrement, dMaxAngle, dMinAngle);
	return result;
}

BOOL IBasicScan::SetParams(long Method, long Filter, long OperationMode, long HitType, long NominalMode, long BoundaryCondition)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4;
	InvokeHelper(0x1c, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		Method, Filter, OperationMode, HitType, NominalMode, BoundaryCondition);
	return result;
}

BOOL IBasicScan::GetParams(long* Method, long* Filter, long* OperationMode, long* HitType, long* NominalMode, long* BoundaryCondition)
{
	BOOL result;
	static BYTE parms[] =
		VTS_PI4 VTS_PI4 VTS_PI4 VTS_PI4 VTS_PI4 VTS_PI4;
	InvokeHelper(0x1d, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		Method, Filter, OperationMode, HitType, NominalMode, BoundaryCondition);
	return result;
}

BOOL IBasicScan::SetMethodPointData(LPDISPATCH MethodStart, LPDISPATCH MethodEnd, LPDISPATCH MethodInitTouch, LPDISPATCH MethodEndTouch, LPDISPATCH MethodInitDir, LPDISPATCH MethodInitTopSurf, LPDISPATCH MethodCutPlane)
{
	BOOL result;
	static BYTE parms[] =
		VTS_DISPATCH VTS_DISPATCH VTS_DISPATCH VTS_DISPATCH VTS_DISPATCH VTS_DISPATCH VTS_DISPATCH;
	InvokeHelper(0x1e, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		MethodStart, MethodEnd, MethodInitTouch, MethodEndTouch, MethodInitDir, MethodInitTopSurf, MethodCutPlane);
	return result;
}

BOOL IBasicScan::GetMethodPointData(LPDISPATCH MethodStart, LPDISPATCH MethodEnd, LPDISPATCH MethodInitTouch, LPDISPATCH MethodEndTouch, LPDISPATCH MethodInitDir, LPDISPATCH MethodInitTopSurf, LPDISPATCH MethodCutPlane)
{
	BOOL result;
	static BYTE parms[] =
		VTS_DISPATCH VTS_DISPATCH VTS_DISPATCH VTS_DISPATCH VTS_DISPATCH VTS_DISPATCH VTS_DISPATCH;
	InvokeHelper(0x1f, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		MethodStart, MethodEnd, MethodInitTouch, MethodEndTouch, MethodInitDir, MethodInitTopSurf, MethodCutPlane);
	return result;
}

BOOL IBasicScan::CreateBasicScan()
{
	BOOL result;
	InvokeHelper(0x20, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
	return result;
}

BOOL IBasicScan::GetBoundaryPoint(long index, double* X, double* Y, double* Z)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4 VTS_PR8 VTS_PR8 VTS_PR8;
	InvokeHelper(0x21, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		index, X, Y, Z);
	return result;
}

BOOL IBasicScan::SetBoundaryPoint(long index, double X, double Y, double Z)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4 VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0x22, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		index, X, Y, Z);
	return result;
}

BOOL IBasicScan::AddControlPoint(LPDISPATCH ControlPoint)
{
	BOOL result;
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x23, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		ControlPoint);
	return result;
}

LPDISPATCH IBasicScan::GetControlPoint(long index)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x24, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		index);
	return result;
}

BOOL IBasicScan::SetControlPoint(long index, LPDISPATCH ControlPoint)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4 VTS_DISPATCH;
	InvokeHelper(0x25, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		index, ControlPoint);
	return result;
}

BOOL IBasicScan::RemoveControlPoint(long index)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x26, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		index);
	return result;
}

BOOL IBasicScan::GetHitTValue(long index, double* T)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4 VTS_PR8;
	InvokeHelper(0x2b, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		index, T);
	return result;
}

BOOL IBasicScan::GenerateScan()
{
	BOOL result;
	InvokeHelper(0x2c, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IControlPoint properties

double IControlPoint::GetX()
{
	double result;
	GetProperty(0x1, VT_R8, (void*)&result);
	return result;
}

void IControlPoint::SetX(double propVal)
{
	SetProperty(0x1, VT_R8, propVal);
}

double IControlPoint::GetY()
{
	double result;
	GetProperty(0x2, VT_R8, (void*)&result);
	return result;
}

void IControlPoint::SetY(double propVal)
{
	SetProperty(0x2, VT_R8, propVal);
}

double IControlPoint::GetZ()
{
	double result;
	GetProperty(0x3, VT_R8, (void*)&result);
	return result;
}

void IControlPoint::SetZ(double propVal)
{
	SetProperty(0x3, VT_R8, propVal);
}

double IControlPoint::GetI()
{
	double result;
	GetProperty(0x4, VT_R8, (void*)&result);
	return result;
}

void IControlPoint::SetI(double propVal)
{
	SetProperty(0x4, VT_R8, propVal);
}

double IControlPoint::GetJ()
{
	double result;
	GetProperty(0x5, VT_R8, (void*)&result);
	return result;
}

void IControlPoint::SetJ(double propVal)
{
	SetProperty(0x5, VT_R8, propVal);
}

double IControlPoint::GetK()
{
	double result;
	GetProperty(0x6, VT_R8, (void*)&result);
	return result;
}

void IControlPoint::SetK(double propVal)
{
	SetProperty(0x6, VT_R8, propVal);
}

long IControlPoint::GetType()
{
	long result;
	GetProperty(0x7, VT_I4, (void*)&result);
	return result;
}

void IControlPoint::SetType(long propVal)
{
	SetProperty(0x7, VT_I4, propVal);
}

double IControlPoint::GetRadius()
{
	double result;
	GetProperty(0x8, VT_R8, (void*)&result);
	return result;
}

void IControlPoint::SetRadius(double propVal)
{
	SetProperty(0x8, VT_R8, propVal);
}

double IControlPoint::GetSpeed()
{
	double result;
	GetProperty(0x9, VT_R8, (void*)&result);
	return result;
}

void IControlPoint::SetSpeed(double propVal)
{
	SetProperty(0x9, VT_R8, propVal);
}

long IControlPoint::GetPointDensity()
{
	long result;
	GetProperty(0xa, VT_I4, (void*)&result);
	return result;
}

void IControlPoint::SetPointDensity(long propVal)
{
	SetProperty(0xa, VT_I4, propVal);
}

long IControlPoint::GetCrossings()
{
	long result;
	GetProperty(0xb, VT_I4, (void*)&result);
	return result;
}

void IControlPoint::SetCrossings(long propVal)
{
	SetProperty(0xb, VT_I4, propVal);
}

double IControlPoint::GetPointDensity2()
{
	double result;
	GetProperty(0xc, VT_R8, (void*)&result);
	return result;
}

void IControlPoint::SetPointDensity2(double propVal)
{
	SetProperty(0xc, VT_R8, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IControlPoint operations


/////////////////////////////////////////////////////////////////////////////
// ICalibration properties

CString ICalibration::GetSphereID()
{
	CString result;
	GetProperty(0x1, VT_BSTR, (void*)&result);
	return result;
}

void ICalibration::SetSphereID(LPCTSTR propVal)
{
	SetProperty(0x1, VT_BSTR, propVal);
}

CString ICalibration::GetToolID()
{
	CString result;
	GetProperty(0x2, VT_BSTR, (void*)&result);
	return result;
}

void ICalibration::SetToolID(LPCTSTR propVal)
{
	SetProperty(0x2, VT_BSTR, propVal);
}

BOOL ICalibration::GetMoved()
{
	BOOL result;
	GetProperty(0x3, VT_BOOL, (void*)&result);
	return result;
}

void ICalibration::SetMoved(BOOL propVal)
{
	SetProperty(0x3, VT_BOOL, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// ICalibration operations


/////////////////////////////////////////////////////////////////////////////
// IAttach properties

CString IAttach::GetId()
{
	CString result;
	GetProperty(0x1, VT_BSTR, (void*)&result);
	return result;
}

void IAttach::SetId(LPCTSTR propVal)
{
	SetProperty(0x1, VT_BSTR, propVal);
}

CString IAttach::GetPartName()
{
	CString result;
	GetProperty(0x2, VT_BSTR, (void*)&result);
	return result;
}

void IAttach::SetPartName(LPCTSTR propVal)
{
	SetProperty(0x2, VT_BSTR, propVal);
}

BOOL IAttach::GetExecute()
{
	BOOL result;
	GetProperty(0x3, VT_BOOL, (void*)&result);
	return result;
}

void IAttach::SetExecute(BOOL propVal)
{
	SetProperty(0x3, VT_BOOL, propVal);
}

CString IAttach::GetLocalAlign()
{
	CString result;
	GetProperty(0x4, VT_BSTR, (void*)&result);
	return result;
}

void IAttach::SetLocalAlign(LPCTSTR propVal)
{
	SetProperty(0x4, VT_BSTR, propVal);
}

CString IAttach::GetAttachedAlign()
{
	CString result;
	GetProperty(0x5, VT_BSTR, (void*)&result);
	return result;
}

void IAttach::SetAttachedAlign(LPCTSTR propVal)
{
	SetProperty(0x5, VT_BSTR, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IAttach operations


/////////////////////////////////////////////////////////////////////////////
// IExtCmd properties

CString IExtCmd::GetCommand()
{
	CString result;
	GetProperty(0x1, VT_BSTR, (void*)&result);
	return result;
}

void IExtCmd::SetCommand(LPCTSTR propVal)
{
	SetProperty(0x1, VT_BSTR, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IExtCmd operations


/////////////////////////////////////////////////////////////////////////////
// IOptionProbe properties

double IOptionProbe::GetMaxForce()
{
	double result;
	GetProperty(0x1, VT_R8, (void*)&result);
	return result;
}

void IOptionProbe::SetMaxForce(double propVal)
{
	SetProperty(0x1, VT_R8, propVal);
}

double IOptionProbe::GetLowForce()
{
	double result;
	GetProperty(0x2, VT_R8, (void*)&result);
	return result;
}

void IOptionProbe::SetLowForce(double propVal)
{
	SetProperty(0x2, VT_R8, propVal);
}

double IOptionProbe::GetUpperForce()
{
	double result;
	GetProperty(0x3, VT_R8, (void*)&result);
	return result;
}

void IOptionProbe::SetUpperForce(double propVal)
{
	SetProperty(0x3, VT_R8, propVal);
}

double IOptionProbe::GetTriggerForce()
{
	double result;
	GetProperty(0x4, VT_R8, (void*)&result);
	return result;
}

void IOptionProbe::SetTriggerForce(double propVal)
{
	SetProperty(0x4, VT_R8, propVal);
}

double IOptionProbe::GetProbeAccuracy()
{
	double result;
	GetProperty(0x5, VT_R8, (void*)&result);
	return result;
}

void IOptionProbe::SetProbeAccuracy(double propVal)
{
	SetProperty(0x5, VT_R8, propVal);
}

double IOptionProbe::GetPositionalAccuracy()
{
	double result;
	GetProperty(0x6, VT_R8, (void*)&result);
	return result;
}

void IOptionProbe::SetPositionalAccuracy(double propVal)
{
	SetProperty(0x6, VT_R8, propVal);
}

double IOptionProbe::GetReturnData()
{
	double result;
	GetProperty(0x7, VT_R8, (void*)&result);
	return result;
}

void IOptionProbe::SetReturnData(double propVal)
{
	SetProperty(0x7, VT_R8, propVal);
}

double IOptionProbe::GetReturnSpeed()
{
	double result;
	GetProperty(0x8, VT_R8, (void*)&result);
	return result;
}

void IOptionProbe::SetReturnSpeed(double propVal)
{
	SetProperty(0x8, VT_R8, propVal);
}

double IOptionProbe::GetScanPointDensity()
{
	double result;
	GetProperty(0x9, VT_R8, (void*)&result);
	return result;
}

void IOptionProbe::SetScanPointDensity(double propVal)
{
	SetProperty(0x9, VT_R8, propVal);
}

double IOptionProbe::GetScanAcceleration()
{
	double result;
	GetProperty(0xa, VT_R8, (void*)&result);
	return result;
}

void IOptionProbe::SetScanAcceleration(double propVal)
{
	SetProperty(0xa, VT_R8, propVal);
}

double IOptionProbe::GetScanOffsetForce()
{
	double result;
	GetProperty(0xb, VT_R8, (void*)&result);
	return result;
}

void IOptionProbe::SetScanOffsetForce(double propVal)
{
	SetProperty(0xb, VT_R8, propVal);
}

CString IOptionProbe::GetProbingMode()
{
	CString result;
	GetProperty(0xc, VT_BSTR, (void*)&result);
	return result;
}

void IOptionProbe::SetProbingMode(LPCTSTR propVal)
{
	SetProperty(0xc, VT_BSTR, propVal);
}

long IOptionProbe::GetManFineProbing()
{
	long result;
	GetProperty(0xd, VT_I4, (void*)&result);
	return result;
}

void IOptionProbe::SetManFineProbing(long propVal)
{
	SetProperty(0xd, VT_I4, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IOptionProbe operations


/////////////////////////////////////////////////////////////////////////////
// ILeapfrog properties

short ILeapfrog::GetLeapfrogtype()
{
	short result;
	GetProperty(0x1, VT_I2, (void*)&result);
	return result;
}

void ILeapfrog::SetLeapfrogtype(short propVal)
{
	SetProperty(0x1, VT_I2, propVal);
}

short ILeapfrog::GetNumHits()
{
	short result;
	GetProperty(0x2, VT_I2, (void*)&result);
	return result;
}

void ILeapfrog::SetNumHits(short propVal)
{
	SetProperty(0x2, VT_I2, propVal);
}

long ILeapfrog::GetFull()
{
	long result;
	GetProperty(0x3, VT_I4, (void*)&result);
	return result;
}

void ILeapfrog::SetFull(long propVal)
{
	SetProperty(0x3, VT_I4, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// ILeapfrog operations


/////////////////////////////////////////////////////////////////////////////
// IOptMotion properties

double IOptMotion::GetMaxXAcceleration()
{
	double result;
	GetProperty(0x1, VT_R8, (void*)&result);
	return result;
}

void IOptMotion::SetMaxXAcceleration(double propVal)
{
	SetProperty(0x1, VT_R8, propVal);
}

double IOptMotion::GetMaxYAcceleration()
{
	double result;
	GetProperty(0x2, VT_R8, (void*)&result);
	return result;
}

void IOptMotion::SetMaxYAcceleration(double propVal)
{
	SetProperty(0x2, VT_R8, propVal);
}

double IOptMotion::GetMaxZAcceleration()
{
	double result;
	GetProperty(0x3, VT_R8, (void*)&result);
	return result;
}

void IOptMotion::SetMaxZAcceleration(double propVal)
{
	SetProperty(0x3, VT_R8, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IOptMotion operations


/////////////////////////////////////////////////////////////////////////////
// IArrayIndex properties

/////////////////////////////////////////////////////////////////////////////
// IArrayIndex operations

BOOL IArrayIndex::AddIndexSet(long LowerBound, long UpperBound)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4 VTS_I4;
	InvokeHelper(0x1, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		LowerBound, UpperBound);
	return result;
}

BOOL IArrayIndex::SetUpperBound(long index, long UpperBound)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4 VTS_I4;
	InvokeHelper(0x2, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		index, UpperBound);
	return result;
}

BOOL IArrayIndex::SetLowerBound(long index, long LowerBound)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4 VTS_I4;
	InvokeHelper(0x3, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		index, LowerBound);
	return result;
}

BOOL IArrayIndex::RemoveIndexSet(long index)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x4, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		index);
	return result;
}

long IArrayIndex::GetLowerBound(long index)
{
	long result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		index);
	return result;
}

long IArrayIndex::GetUpperBound(long index)
{
	long result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		index);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IFileIO properties

long IFileIO::GetFileIOType()
{
	long result;
	GetProperty(0x1, VT_I4, (void*)&result);
	return result;
}

void IFileIO::SetFileIOType(long propVal)
{
	SetProperty(0x1, VT_I4, propVal);
}

long IFileIO::GetFileOpenType()
{
	long result;
	GetProperty(0x2, VT_I4, (void*)&result);
	return result;
}

void IFileIO::SetFileOpenType(long propVal)
{
	SetProperty(0x2, VT_I4, propVal);
}

CString IFileIO::GetFilePointerID()
{
	CString result;
	GetProperty(0x3, VT_BSTR, (void*)&result);
	return result;
}

void IFileIO::SetFilePointerID(LPCTSTR propVal)
{
	SetProperty(0x3, VT_BSTR, propVal);
}

CString IFileIO::GetExpression()
{
	CString result;
	GetProperty(0x4, VT_BSTR, (void*)&result);
	return result;
}

void IFileIO::SetExpression(LPCTSTR propVal)
{
	SetProperty(0x4, VT_BSTR, propVal);
}

CString IFileIO::GetVariableID()
{
	CString result;
	GetProperty(0x5, VT_BSTR, (void*)&result);
	return result;
}

void IFileIO::SetVariableID(LPCTSTR propVal)
{
	SetProperty(0x5, VT_BSTR, propVal);
}

long IFileIO::GetBufferSize()
{
	long result;
	GetProperty(0x6, VT_I4, (void*)&result);
	return result;
}

void IFileIO::SetBufferSize(long propVal)
{
	SetProperty(0x6, VT_I4, propVal);
}

CString IFileIO::GetFileName1()
{
	CString result;
	GetProperty(0x7, VT_BSTR, (void*)&result);
	return result;
}

void IFileIO::SetFileName1(LPCTSTR propVal)
{
	SetProperty(0x7, VT_BSTR, propVal);
}

CString IFileIO::GetFileName2()
{
	CString result;
	GetProperty(0x8, VT_BSTR, (void*)&result);
	return result;
}

void IFileIO::SetFileName2(LPCTSTR propVal)
{
	SetProperty(0x8, VT_BSTR, propVal);
}

BOOL IFileIO::GetFailIfExists()
{
	BOOL result;
	GetProperty(0x9, VT_BOOL, (void*)&result);
	return result;
}

void IFileIO::SetFailIfExists(BOOL propVal)
{
	SetProperty(0x9, VT_BOOL, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IFileIO operations


/////////////////////////////////////////////////////////////////////////////
// ITempComp properties

double ITempComp::GetMaterialCoefficient()
{
	double result;
	GetProperty(0x1, VT_R8, (void*)&result);
	return result;
}

void ITempComp::SetMaterialCoefficient(double propVal)
{
	SetProperty(0x1, VT_R8, propVal);
}

double ITempComp::GetRefTemp()
{
	double result;
	GetProperty(0x2, VT_R8, (void*)&result);
	return result;
}

void ITempComp::SetRefTemp(double propVal)
{
	SetProperty(0x2, VT_R8, propVal);
}

double ITempComp::GetHighThreshold()
{
	double result;
	GetProperty(0x3, VT_R8, (void*)&result);
	return result;
}

void ITempComp::SetHighThreshold(double propVal)
{
	SetProperty(0x3, VT_R8, propVal);
}

double ITempComp::GetLowTheshold()
{
	double result;
	GetProperty(0x4, VT_R8, (void*)&result);
	return result;
}

void ITempComp::SetLowTheshold(double propVal)
{
	SetProperty(0x4, VT_R8, propVal);
}

CString ITempComp::GetSensors()
{
	CString result;
	GetProperty(0x5, VT_BSTR, (void*)&result);
	return result;
}

void ITempComp::SetSensors(LPCTSTR propVal)
{
	SetProperty(0x5, VT_BSTR, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// ITempComp operations

BOOL ITempComp::SetOrigin(double X, double Y, double Z)
{
	BOOL result;
	static BYTE parms[] =
		VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		X, Y, Z);
	return result;
}

BOOL ITempComp::GetOrigin(double* X, double* Y, double* Z)
{
	BOOL result;
	static BYTE parms[] =
		VTS_PR8 VTS_PR8 VTS_PR8;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		X, Y, Z);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IDispMetaFile properties

CString IDispMetaFile::GetComment()
{
	CString result;
	GetProperty(0x1, VT_BSTR, (void*)&result);
	return result;
}

void IDispMetaFile::SetComment(LPCTSTR propVal)
{
	SetProperty(0x1, VT_BSTR, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IDispMetaFile operations


/////////////////////////////////////////////////////////////////////////////
// IComment properties

long IComment::GetCommentType()
{
	long result;
	GetProperty(0x1, VT_I4, (void*)&result);
	return result;
}

void IComment::SetCommentType(long propVal)
{
	SetProperty(0x1, VT_I4, propVal);
}

CString IComment::GetId()
{
	CString result;
	GetProperty(0x2, VT_BSTR, (void*)&result);
	return result;
}

void IComment::SetId(LPCTSTR propVal)
{
	SetProperty(0x2, VT_BSTR, propVal);
}

CString IComment::GetComment()
{
	CString result;
	GetProperty(0x3, VT_BSTR, (void*)&result);
	return result;
}

void IComment::SetComment(LPCTSTR propVal)
{
	SetProperty(0x3, VT_BSTR, propVal);
}

CString IComment::GetInput()
{
	CString result;
	GetProperty(0x4, VT_BSTR, (void*)&result);
	return result;
}

void IComment::SetInput(LPCTSTR propVal)
{
	SetProperty(0x4, VT_BSTR, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IComment operations

CString IComment::GetLine(long Line)
{
	CString result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
		Line);
	return result;
}

BOOL IComment::SetLine(long Line, LPCTSTR Text)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4 VTS_BSTR;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		Line, Text);
	return result;
}

BOOL IComment::AddLine(LPCTSTR Text)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		Text);
	return result;
}

BOOL IComment::RemoveLine(long Line)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x8, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		Line);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IStatistics properties

long IStatistics::GetStatMode()
{
	long result;
	GetProperty(0x1, VT_I4, (void*)&result);
	return result;
}

void IStatistics::SetStatMode(long propVal)
{
	SetProperty(0x1, VT_I4, propVal);
}

long IStatistics::GetReadLock()
{
	long result;
	GetProperty(0x2, VT_I4, (void*)&result);
	return result;
}

void IStatistics::SetReadLock(long propVal)
{
	SetProperty(0x2, VT_I4, propVal);
}

long IStatistics::GetWriteLock()
{
	long result;
	GetProperty(0x3, VT_I4, (void*)&result);
	return result;
}

void IStatistics::SetWriteLock(long propVal)
{
	SetProperty(0x3, VT_I4, propVal);
}

long IStatistics::GetMemoryPages()
{
	long result;
	GetProperty(0x4, VT_I4, (void*)&result);
	return result;
}

void IStatistics::SetMemoryPages(long propVal)
{
	SetProperty(0x4, VT_I4, propVal);
}

long IStatistics::GetNameType()
{
	long result;
	GetProperty(0x5, VT_I4, (void*)&result);
	return result;
}

void IStatistics::SetNameType(long propVal)
{
	SetProperty(0x5, VT_I4, propVal);
}

long IStatistics::GetCalcMode()
{
	long result;
	GetProperty(0x6, VT_I4, (void*)&result);
	return result;
}

void IStatistics::SetCalcMode(long propVal)
{
	SetProperty(0x6, VT_I4, propVal);
}

CString IStatistics::GetTransferDir()
{
	CString result;
	GetProperty(0x7, VT_BSTR, (void*)&result);
	return result;
}

void IStatistics::SetTransferDir(LPCTSTR propVal)
{
	SetProperty(0x7, VT_BSTR, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IStatistics operations

BOOL IStatistics::AddStatsDir(LPCTSTR Dir)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x8, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		Dir);
	return result;
}

CString IStatistics::GetStatsDir(long index)
{
	CString result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x9, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
		index);
	return result;
}

BOOL IStatistics::SetStatsDir(long index, LPCTSTR Dir)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4 VTS_BSTR;
	InvokeHelper(0xa, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		index, Dir);
	return result;
}

BOOL IStatistics::RemoveStatsDir(long index)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0xb, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		index);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ITraceField properties

CString ITraceField::GetName()
{
	CString result;
	GetProperty(0x1, VT_BSTR, (void*)&result);
	return result;
}

void ITraceField::SetName(LPCTSTR propVal)
{
	SetProperty(0x1, VT_BSTR, propVal);
}

CString ITraceField::GetValue()
{
	CString result;
	GetProperty(0x2, VT_BSTR, (void*)&result);
	return result;
}

void ITraceField::SetValue(LPCTSTR propVal)
{
	SetProperty(0x2, VT_BSTR, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// ITraceField operations


/////////////////////////////////////////////////////////////////////////////
// IActiveTip properties

CString IActiveTip::GetTipID()
{
	CString result;
	GetProperty(0x1, VT_BSTR, (void*)&result);
	return result;
}

void IActiveTip::SetTipID(LPCTSTR propVal)
{
	SetProperty(0x1, VT_BSTR, propVal);
}

double IActiveTip::GetAngle()
{
	double result;
	GetProperty(0x2, VT_R8, (void*)&result);
	return result;
}

void IActiveTip::SetAngle(double propVal)
{
	SetProperty(0x2, VT_R8, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IActiveTip operations

BOOL IActiveTip::GetShankVector(double* I, double* J, double* K)
{
	BOOL result;
	static BYTE parms[] =
		VTS_PR8 VTS_PR8 VTS_PR8;
	InvokeHelper(0x3, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		I, J, K);
	return result;
}

BOOL IActiveTip::SetShankVector(double I, double J, double K)
{
	BOOL result;
	static BYTE parms[] =
		VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0x4, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		I, J, K);
	return result;
}

LPDISPATCH IActiveTip::GenCalSphereHits(LPDISPATCH CENTER_POINT, LPDISPATCH center_vector, double diameter, long total_hits, long num_rows, double start_angle1, double end_angle1, double start_angle2, double end_angle2, LPDISPATCH circle_vector)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_DISPATCH VTS_DISPATCH VTS_R8 VTS_I4 VTS_I4 VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_DISPATCH;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		CENTER_POINT, center_vector, diameter, total_hits, num_rows, start_angle1, end_angle1, start_angle2, end_angle2, circle_vector);
	return result;
}

void IActiveTip::SetCalSphereData(double X, double Y, double Z, double I, double J, double K, double diam)
{
	static BYTE parms[] =
		VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 X, Y, Z, I, J, K, diam);
}

void IActiveTip::SetCalData(long totalHits, long NumRows, double startAngle1, double endAngle1, double StartAngle2, double EndAngle2)
{
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 totalHits, NumRows, startAngle1, endAngle1, StartAngle2, EndAngle2);
}

void IActiveTip::SetCalCircleVector(double I, double J, double K)
{
	static BYTE parms[] =
		VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0x8, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 I, J, K);
}

void IActiveTip::GetHits(long Num, double* hitbuffer)
{
	static BYTE parms[] =
		VTS_I4 VTS_PR8;
	InvokeHelper(0x9, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Num, hitbuffer);
}

long IActiveTip::genHitsInfo()
{
	long result;
	InvokeHelper(0xa, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ILoadProbe properties

CString ILoadProbe::GetFilename()
{
	CString result;
	GetProperty(0x1, VT_BSTR, (void*)&result);
	return result;
}

void ILoadProbe::SetFilename(LPCTSTR propVal)
{
	SetProperty(0x1, VT_BSTR, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// ILoadProbe operations


/////////////////////////////////////////////////////////////////////////////
// IDimFormat properties

BOOL IDimFormat::GetShowHeadings()
{
	BOOL result;
	GetProperty(0x1, VT_BOOL, (void*)&result);
	return result;
}

void IDimFormat::SetShowHeadings(BOOL propVal)
{
	SetProperty(0x1, VT_BOOL, propVal);
}

BOOL IDimFormat::GetShowDevSymbols()
{
	BOOL result;
	GetProperty(0x2, VT_BOOL, (void*)&result);
	return result;
}

void IDimFormat::SetShowDevSymbols(BOOL propVal)
{
	SetProperty(0x2, VT_BOOL, propVal);
}

BOOL IDimFormat::GetShowStdDev()
{
	BOOL result;
	GetProperty(0x3, VT_BOOL, (void*)&result);
	return result;
}

void IDimFormat::SetShowStdDev(BOOL propVal)
{
	SetProperty(0x3, VT_BOOL, propVal);
}

BOOL IDimFormat::GetShowDimensionText()
{
	BOOL result;
	GetProperty(0x4, VT_BOOL, (void*)&result);
	return result;
}

void IDimFormat::SetShowDimensionText(BOOL propVal)
{
	SetProperty(0x4, VT_BOOL, propVal);
}

BOOL IDimFormat::GetShowDimensionTextOptions()
{
	BOOL result;
	GetProperty(0x5, VT_BOOL, (void*)&result);
	return result;
}

void IDimFormat::SetShowDimensionTextOptions(BOOL propVal)
{
	SetProperty(0x5, VT_BOOL, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IDimFormat operations

long IDimFormat::GetHeadingType(long index)
{
	long result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		index);
	return result;
}

BOOL IDimFormat::SetHeadingType(long index, long HeadingType)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4 VTS_I4;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		index, HeadingType);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IDimInfo properties

CString IDimInfo::GetDimensionId()
{
	CString result;
	GetProperty(0x1, VT_BSTR, (void*)&result);
	return result;
}

void IDimInfo::SetDimensionId(LPCTSTR propVal)
{
	SetProperty(0x1, VT_BSTR, propVal);
}

BOOL IDimInfo::GetShowDimId()
{
	BOOL result;
	GetProperty(0x2, VT_BOOL, (void*)&result);
	return result;
}

void IDimInfo::SetShowDimId(BOOL propVal)
{
	SetProperty(0x2, VT_BOOL, propVal);
}

BOOL IDimInfo::GetShowFeatId()
{
	BOOL result;
	GetProperty(0x3, VT_BOOL, (void*)&result);
	return result;
}

void IDimInfo::SetShowFeatId(BOOL propVal)
{
	SetProperty(0x3, VT_BOOL, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IDimInfo operations

long IDimInfo::GetFieldFormat(long index)
{
	long result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x4, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		index);
	return result;
}

BOOL IDimInfo::SetFieldFormat(long index, long FieldType)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4 VTS_I4;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		index, FieldType);
	return result;
}

long IDimInfo::GetLocationAxis(long index)
{
	long result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		index);
	return result;
}

BOOL IDimInfo::SetLocationAxis(long index, long AXIS)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4 VTS_I4;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		index, AXIS);
	return result;
}

long IDimInfo::GetTruePosAxis(long index)
{
	long result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x8, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		index);
	return result;
}

BOOL IDimInfo::SetTruePosAxis(long index, long AXIS)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4 VTS_I4;
	InvokeHelper(0x9, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		index, AXIS);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ILoadMachine properties

CString ILoadMachine::GetMachineName()
{
	CString result;
	GetProperty(0x1, VT_BSTR, (void*)&result);
	return result;
}

void ILoadMachine::SetMachineName(LPCTSTR propVal)
{
	SetProperty(0x1, VT_BSTR, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// ILoadMachine operations


/////////////////////////////////////////////////////////////////////////////
// IDataTypes properties

LPDISPATCH IDataTypes::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x1, VT_DISPATCH, (void*)&result);
	return result;
}

void IDataTypes::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x1, VT_DISPATCH, propVal);
}

LPDISPATCH IDataTypes::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x2, VT_DISPATCH, (void*)&result);
	return result;
}

void IDataTypes::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x2, VT_DISPATCH, propVal);
}

long IDataTypes::GetCount()
{
	long result;
	GetProperty(0x3, VT_I4, (void*)&result);
	return result;
}

void IDataTypes::SetCount(long propVal)
{
	SetProperty(0x3, VT_I4, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IDataTypes operations

LPDISPATCH IDataTypes::Item(long Num)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Num);
	return result;
}

LPDISPATCH IDataTypes::GetDataTypeInfo(long DataType)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		DataType);
	return result;
}

LPDISPATCH IDataTypes::_Item(long Identifier)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Identifier);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IDataType properties

LPDISPATCH IDataType::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x1, VT_DISPATCH, (void*)&result);
	return result;
}

void IDataType::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x1, VT_DISPATCH, propVal);
}

LPDISPATCH IDataType::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x2, VT_DISPATCH, (void*)&result);
	return result;
}

void IDataType::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x2, VT_DISPATCH, propVal);
}

long IDataType::GetCount()
{
	long result;
	GetProperty(0x3, VT_I4, (void*)&result);
	return result;
}

void IDataType::SetCount(long propVal)
{
	SetProperty(0x3, VT_I4, propVal);
}

long IDataType::GetValue()
{
	long result;
	GetProperty(0x4, VT_I4, (void*)&result);
	return result;
}

void IDataType::SetValue(long propVal)
{
	SetProperty(0x4, VT_I4, propVal);
}

CString IDataType::GetDescription()
{
	CString result;
	GetProperty(0x5, VT_BSTR, (void*)&result);
	return result;
}

void IDataType::SetDescription(LPCTSTR propVal)
{
	SetProperty(0x5, VT_BSTR, propVal);
}

long IDataType::GetType()
{
	long result;
	GetProperty(0x6, VT_I4, (void*)&result);
	return result;
}

void IDataType::SetType(long propVal)
{
	SetProperty(0x6, VT_I4, propVal);
}

long IDataType::GetDBType()
{
	long result;
	GetProperty(0x7, VT_I4, (void*)&result);
	return result;
}

void IDataType::SetDBType(long propVal)
{
	SetProperty(0x7, VT_I4, propVal);
}

long IDataType::GetVariableType()
{
	long result;
	GetProperty(0x8, VT_I4, (void*)&result);
	return result;
}

void IDataType::SetVariableType(long propVal)
{
	SetProperty(0x8, VT_I4, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IDataType operations


/////////////////////////////////////////////////////////////////////////////
// IToolkitInternalCommands properties

LPDISPATCH IToolkitInternalCommands::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x1, VT_DISPATCH, (void*)&result);
	return result;
}

void IToolkitInternalCommands::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x1, VT_DISPATCH, propVal);
}

LPDISPATCH IToolkitInternalCommands::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x2, VT_DISPATCH, (void*)&result);
	return result;
}

void IToolkitInternalCommands::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x2, VT_DISPATCH, propVal);
}

long IToolkitInternalCommands::GetCount()
{
	long result;
	GetProperty(0x3, VT_I4, (void*)&result);
	return result;
}

void IToolkitInternalCommands::SetCount(long propVal)
{
	SetProperty(0x3, VT_I4, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IToolkitInternalCommands operations

LPDISPATCH IToolkitInternalCommands::Item(const VARIANT& NameorNum)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&NameorNum);
	return result;
}

LPDISPATCH IToolkitInternalCommands::_Item(const VARIANT& NameorNum)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&NameorNum);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IStrategies properties

LPDISPATCH IStrategies::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x1, VT_DISPATCH, (void*)&result);
	return result;
}

void IStrategies::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x1, VT_DISPATCH, propVal);
}

LPDISPATCH IStrategies::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x2, VT_DISPATCH, (void*)&result);
	return result;
}

void IStrategies::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x2, VT_DISPATCH, propVal);
}

long IStrategies::GetCount()
{
	long result;
	GetProperty(0x3, VT_I4, (void*)&result);
	return result;
}

void IStrategies::SetCount(long propVal)
{
	SetProperty(0x3, VT_I4, propVal);
}

LPDISPATCH IStrategies::GetCurrentStrategy()
{
	LPDISPATCH result;
	GetProperty(0x4, VT_DISPATCH, (void*)&result);
	return result;
}

void IStrategies::SetCurrentStrategy(LPDISPATCH propVal)
{
	SetProperty(0x4, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IStrategies operations

LPDISPATCH IStrategies::Item(const VARIANT& IndexOrName)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&IndexOrName);
	return result;
}

BOOL IStrategies::SetCurrentStrategy(const VARIANT& IndexOrName)
{
	BOOL result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		&IndexOrName);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IStrategy properties

LPDISPATCH IStrategy::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x1, VT_DISPATCH, (void*)&result);
	return result;
}

void IStrategy::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x1, VT_DISPATCH, propVal);
}

LPDISPATCH IStrategy::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x2, VT_DISPATCH, (void*)&result);
	return result;
}

void IStrategy::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x2, VT_DISPATCH, propVal);
}

CString IStrategy::GetName()
{
	CString result;
	GetProperty(0x3, VT_BSTR, (void*)&result);
	return result;
}

void IStrategy::SetName(LPCTSTR propVal)
{
	SetProperty(0x3, VT_BSTR, propVal);
}

BOOL IStrategy::GetIsDefaultStrategy()
{
	BOOL result;
	GetProperty(0x4, VT_BOOL, (void*)&result);
	return result;
}

void IStrategy::SetIsDefaultStrategy(BOOL propVal)
{
	SetProperty(0x4, VT_BOOL, propVal);
}

long IStrategy::GetIndex()
{
	long result;
	GetProperty(0x5, VT_I4, (void*)&result);
	return result;
}

void IStrategy::SetIndex(long propVal)
{
	SetProperty(0x5, VT_I4, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IStrategy operations


/////////////////////////////////////////////////////////////////////////////
// IDialog properties

BOOL IDialog::GetVisible()
{
	BOOL result;
	GetProperty(0x1, VT_BOOL, (void*)&result);
	return result;
}

void IDialog::SetVisible(BOOL propVal)
{
	SetProperty(0x1, VT_BOOL, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IDialog operations


/////////////////////////////////////////////////////////////////////////////
// IVariable properties

long IVariable::GetVariableType()
{
	long result;
	GetProperty(0x1, VT_I4, (void*)&result);
	return result;
}

void IVariable::SetVariableType(long propVal)
{
	SetProperty(0x1, VT_I4, propVal);
}

long IVariable::GetLongValue()
{
	long result;
	GetProperty(0x2, VT_I4, (void*)&result);
	return result;
}

void IVariable::SetLongValue(long propVal)
{
	SetProperty(0x2, VT_I4, propVal);
}

double IVariable::GetDoubleValue()
{
	double result;
	GetProperty(0x3, VT_R8, (void*)&result);
	return result;
}

void IVariable::SetDoubleValue(double propVal)
{
	SetProperty(0x3, VT_R8, propVal);
}

CString IVariable::GetStringValue()
{
	CString result;
	GetProperty(0x4, VT_BSTR, (void*)&result);
	return result;
}

void IVariable::SetStringValue(LPCTSTR propVal)
{
	SetProperty(0x4, VT_BSTR, propVal);
}

LPDISPATCH IVariable::GetPointValue()
{
	LPDISPATCH result;
	GetProperty(0x5, VT_DISPATCH, (void*)&result);
	return result;
}

void IVariable::SetPointValue(LPDISPATCH propVal)
{
	SetProperty(0x5, VT_DISPATCH, propVal);
}

LPDISPATCH IVariable::GetCommandValue()
{
	LPDISPATCH result;
	GetProperty(0x6, VT_DISPATCH, (void*)&result);
	return result;
}

void IVariable::SetCommandValue(LPDISPATCH propVal)
{
	SetProperty(0x6, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IVariable operations

long IVariable::GetArrayUpperBound()
{
	long result;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
	return result;
}

long IVariable::GetArrayLowerBound()
{
	long result;
	InvokeHelper(0x8, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
	return result;
}

LPDISPATCH IVariable::GetArrayIndexValue(long index)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x9, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		index);
	return result;
}

BOOL IVariable::SetArrayIndexValue(long index, LPDISPATCH Variable)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4 VTS_DISPATCH;
	InvokeHelper(0xa, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		index, Variable);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IOldBasic properties

LPDISPATCH IOldBasic::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x63, VT_DISPATCH, (void*)&result);
	return result;
}

void IOldBasic::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x63, VT_DISPATCH, propVal);
}

LPDISPATCH IOldBasic::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x64, VT_DISPATCH, (void*)&result);
	return result;
}

void IOldBasic::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x64, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IOldBasic operations

void IOldBasic::AddBoundaryPoint(double X, double Y, double Z)
{
	static BYTE parms[] =
		VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0x1, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 X, Y, Z);
}

void IOldBasic::AddFeature(LPCTSTR ID, double off1, double off2, double off3)
{
	static BYTE parms[] =
		VTS_BSTR VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0x2, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 ID, off1, off2, off3);
}

void IOldBasic::AddLevelFeat(LPCTSTR ID)
{
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x3, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 ID);
}

void IOldBasic::AddOriginFeat(LPCTSTR ID)
{
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x4, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 ID);
}

void IOldBasic::AddRotateFeat(LPCTSTR ID)
{
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 ID);
}

void IOldBasic::BestFit2D(long num_inputs, long Workplane)
{
	static BYTE parms[] =
		VTS_I4 VTS_I4;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 num_inputs, Workplane);
}

void IOldBasic::BestFit3D(long num_inputs)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 num_inputs);
}

void IOldBasic::Calibrate(LPCTSTR sphere, LPCTSTR tool, long Moved)
{
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR VTS_I4;
	InvokeHelper(0x8, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 sphere, tool, Moved);
}

void IOldBasic::CatchMotionError(long tog, long* catch_error)
{
	static BYTE parms[] =
		VTS_I4 VTS_PI4;
	InvokeHelper(0x9, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 tog, catch_error);
}

void IOldBasic::Check(double DISTANCE)
{
	static BYTE parms[] =
		VTS_R8;
	InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 DISTANCE);
}

void IOldBasic::ClearPlane(long plane1, double val1, long plane2, double val2)
{
	static BYTE parms[] =
		VTS_I4 VTS_R8 VTS_I4 VTS_R8;
	InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 plane1, val1, plane2, val2);
}

void IOldBasic::Column132(long tog)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 tog);
}

void IOldBasic::Comment(long ctype, LPCTSTR Comment)
{
	static BYTE parms[] =
		VTS_I4 VTS_BSTR;
	InvokeHelper(0xd, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 ctype, Comment);
}

void IOldBasic::CreateID(BSTR* ID, long ftype)
{
	static BYTE parms[] =
		VTS_PBSTR VTS_I4;
	InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 ID, ftype);
}

void IOldBasic::DefaultAxes()
{
	InvokeHelper(0xf, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IOldBasic::DefaultHits()
{
	InvokeHelper(0x10, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IOldBasic::DimFormat(long flags, long heading1, long heading2, long heading3, long heading4, long heading5, long heading6)
{
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4;
	InvokeHelper(0x11, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 flags, heading1, heading2, heading3, heading4, heading5, heading6);
}

void IOldBasic::EndAlign()
{
	InvokeHelper(0x12, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IOldBasic::EndDim()
{
	InvokeHelper(0x13, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IOldBasic::EndFeature()
{
	InvokeHelper(0x14, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IOldBasic::EndGetFeatPoint()
{
	InvokeHelper(0x15, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IOldBasic::EndScan()
{
	InvokeHelper(0x16, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IOldBasic::EquateAlign(LPCTSTR align1, LPCTSTR align2)
{
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR;
	InvokeHelper(0x17, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 align1, align2);
}

void IOldBasic::Feature(LPCTSTR ID, double pnt_tol)
{
	static BYTE parms[] =
		VTS_BSTR VTS_R8;
	InvokeHelper(0x18, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 ID, pnt_tol);
}

void IOldBasic::GapOnly(long tog)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x19, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 tog);
}

void IOldBasic::Hit(double X, double Y, double Z, double I, double J, double K)
{
	static BYTE parms[] =
		VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0x1a, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 X, Y, Z, I, J, K);
}

void IOldBasic::IgnoreMotionError(long tog)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x1b, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 tog);
}

void IOldBasic::Iterate(double pnt_tol, long flags)
{
	static BYTE parms[] =
		VTS_R8 VTS_I4;
	InvokeHelper(0x1c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 pnt_tol, flags);
}

void IOldBasic::Level(long AXIS, LPCTSTR feat)
{
	static BYTE parms[] =
		VTS_I4 VTS_BSTR;
	InvokeHelper(0x1d, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 AXIS, feat);
}

void IOldBasic::LoadProbe(LPCTSTR probe)
{
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x1e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 probe);
}

void IOldBasic::Mode(long Mode)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x1f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Mode);
}

void IOldBasic::Move(long tog, double X, double Y, double Z, long Direction)
{
	static BYTE parms[] =
		VTS_I4 VTS_R8 VTS_R8 VTS_R8 VTS_I4;
	InvokeHelper(0x20, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 tog, X, Y, Z, Direction);
}

void IOldBasic::MoveSpeed(double percent)
{
	static BYTE parms[] =
		VTS_R8;
	InvokeHelper(0x21, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 percent);
}

void IOldBasic::PreHit(double DISTANCE)
{
	static BYTE parms[] =
		VTS_R8;
	InvokeHelper(0x22, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 DISTANCE);
}

void IOldBasic::ProbeComp(long tog)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x23, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 tog);
}

void IOldBasic::RecallEx(LPCTSTR recallID, LPCTSTR fname)
{
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR;
	InvokeHelper(0x24, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 recallID, fname);
}

void IOldBasic::RecallIn(LPCTSTR recallID)
{
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x25, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 recallID);
}

void IOldBasic::Retract(double DISTANCE)
{
	static BYTE parms[] =
		VTS_R8;
	InvokeHelper(0x26, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 DISTANCE);
}

void IOldBasic::RetroOnly(long tog)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x27, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 tog);
}

void IOldBasic::Rotate(long axis1, LPCTSTR feat, long axis2)
{
	static BYTE parms[] =
		VTS_I4 VTS_BSTR VTS_I4;
	InvokeHelper(0x28, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 axis1, feat, axis2);
}

void IOldBasic::RotateCircle(LPCTSTR Feat1, LPCTSTR Feat2, long axis1, long axis2)
{
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR VTS_I4 VTS_I4;
	InvokeHelper(0x29, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Feat1, Feat2, axis1, axis2);
}

void IOldBasic::RotateOffset(double Offset, long AXIS)
{
	static BYTE parms[] =
		VTS_R8 VTS_I4;
	InvokeHelper(0x2a, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Offset, AXIS);
}

void IOldBasic::SaveAlign(LPCTSTR AlignID, LPCTSTR fname)
{
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR;
	InvokeHelper(0x2b, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 AlignID, fname);
}

void IOldBasic::SetAutoParams(const VARIANT& INIT_HITS, const VARIANT& PERM_HITS, const VARIANT& Depth, const VARIANT& Height, const VARIANT& wdth, const VARIANT& Radius, const VARIANT& Spacer, const VARIANT& Indent, const VARIANT& Thickness, 
		const VARIANT& DISTANCE, const VARIANT& major, const VARIANT& minor)
{
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x2c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 &INIT_HITS, &PERM_HITS, &Depth, &Height, &wdth, &Radius, &Spacer, &Indent, &Thickness, &DISTANCE, &major, &minor);
}

void IOldBasic::SetAutoVector(long index, double I, double J, double K)
{
	static BYTE parms[] =
		VTS_I4 VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0x2d, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 index, I, J, K);
}

void IOldBasic::SetNoms(long dtype, const VARIANT& nom, const VARIANT& plus_tol, const VARIANT& minus_tol, const VARIANT& multiplier)
{
	static BYTE parms[] =
		VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x2e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 dtype, &nom, &plus_tol, &minus_tol, &multiplier);
}

void IOldBasic::SetPrintOptions(long Location, long Draft, long Filemode, long ExtNum)
{
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_I4 VTS_I4;
	InvokeHelper(0x2f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Location, Draft, Filemode, ExtNum);
}

void IOldBasic::SetProgramOption(long opt, long tog)
{
	static BYTE parms[] =
		VTS_I4 VTS_I4;
	InvokeHelper(0x30, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 opt, tog);
}

void IOldBasic::SetProgramValue(long opt, double val)
{
	static BYTE parms[] =
		VTS_I4 VTS_R8;
	InvokeHelper(0x31, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 opt, val);
}

void IOldBasic::SetReportOptions(long opt)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x32, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 opt);
}

void IOldBasic::SetSlaveMode(long tog)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x33, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 tog);
}

void IOldBasic::SetTheos(const VARIANT& X, const VARIANT& Y, const VARIANT& Z, const VARIANT& I, const VARIANT& J, const VARIANT& K, const VARIANT& diam, const VARIANT& Length, const VARIANT& Angle, const VARIANT& small_diam, const VARIANT& start_angle, 
		const VARIANT& end_angle, const VARIANT& start_angle2, const VARIANT& end_angle2)
{
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x34, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 &X, &Y, &Z, &I, &J, &K, &diam, &Length, &Angle, &small_diam, &start_angle, &end_angle, &start_angle2, &end_angle2);
}

void IOldBasic::SetRMeasMode(long Mode)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x35, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Mode);
}

void IOldBasic::SetScanHitParams(long htype, long INIT_HITS, long PERM_HITS, double Spacer, double Depth, double Indent, long flags)
{
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_I4 VTS_R8 VTS_R8 VTS_R8 VTS_I4;
	InvokeHelper(0x36, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 htype, INIT_HITS, PERM_HITS, Spacer, Depth, Indent, flags);
}

void IOldBasic::SetScanHitVectors(long Vector, long I, long J, long K)
{
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_I4 VTS_I4;
	InvokeHelper(0x37, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Vector, I, J, K);
}

void IOldBasic::SetScanParams(double incr, long AXIS, double max_incr, double min_incr, double MAX_ANGLE, double MIN_ANGLE, double delta, double DISTANCE, double incr2, long axis2, double surf_thickness)
{
	static BYTE parms[] =
		VTS_R8 VTS_I4 VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_I4 VTS_R8;
	InvokeHelper(0x38, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 incr, AXIS, max_incr, min_incr, MAX_ANGLE, MIN_ANGLE, delta, DISTANCE, incr2, axis2, surf_thickness);
}

void IOldBasic::SetScanVectors(long Vector, double I, double J, double K)
{
	static BYTE parms[] =
		VTS_I4 VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0x39, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Vector, I, J, K);
}

void IOldBasic::ShowXYZWindow(long show)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x3a, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 show);
}

void IOldBasic::StartAlign(LPCTSTR ID, LPCTSTR recallID)
{
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR;
	InvokeHelper(0x3b, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 ID, recallID);
}

void IOldBasic::StartDim(long dtype, LPCTSTR ID, LPCTSTR Feat1, LPCTSTR Feat2, LPCTSTR Feat3, long AXIS, double Length, double Angle, long flags)
{
	static BYTE parms[] =
		VTS_I4 VTS_BSTR VTS_BSTR VTS_BSTR VTS_BSTR VTS_I4 VTS_R8 VTS_R8 VTS_I4;
	InvokeHelper(0x3c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 dtype, ID, Feat1, Feat2, Feat3, AXIS, Length, Angle, flags);
}

void IOldBasic::StartFeature(long ftype, LPCTSTR ID, LPCTSTR RefID, long hits, long rows, long inputs, long flags, long RefPlane)
{
	static BYTE parms[] =
		VTS_I4 VTS_BSTR VTS_BSTR VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4;
	InvokeHelper(0x3d, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 ftype, ID, RefID, hits, rows, inputs, flags, RefPlane);
}

void IOldBasic::StartScan(LPCTSTR ID, long Mode, long stype, long dir1, long dir2, long technique, long num_bnd_pnts, long flags)
{
	static BYTE parms[] =
		VTS_BSTR VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4;
	InvokeHelper(0x3e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 ID, Mode, stype, dir1, dir2, technique, num_bnd_pnts, flags);
}

void IOldBasic::Stats(long tog, LPCTSTR dbase_dir, long read_lock, long write_lock, long mem_page, long flags)
{
	static BYTE parms[] =
		VTS_I4 VTS_BSTR VTS_I4 VTS_I4 VTS_I4 VTS_I4;
	InvokeHelper(0x3f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 tog, dbase_dir, read_lock, write_lock, mem_page, flags);
}

void IOldBasic::Tip(LPCTSTR Tip, double I, double J, double K, double Angle)
{
	static BYTE parms[] =
		VTS_BSTR VTS_R8 VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0x40, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Tip, I, J, K, Angle);
}

void IOldBasic::Touchspeed(double percent)
{
	static BYTE parms[] =
		VTS_R8;
	InvokeHelper(0x41, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 percent);
}

void IOldBasic::Trace(LPCTSTR field)
{
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x42, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 field);
}

void IOldBasic::Translate(long AXIS, LPCTSTR feat)
{
	static BYTE parms[] =
		VTS_I4 VTS_BSTR;
	InvokeHelper(0x43, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 AXIS, feat);
}

void IOldBasic::TranslateOffset(double Offset, long AXIS)
{
	static BYTE parms[] =
		VTS_R8 VTS_I4;
	InvokeHelper(0x44, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Offset, AXIS);
}

double IOldBasic::ArcCos(double X)
{
	double result;
	static BYTE parms[] =
		VTS_R8;
	InvokeHelper(0x45, DISPATCH_METHOD, VT_R8, (void*)&result, parms,
		X);
	return result;
}

double IOldBasic::ArcSin(double X)
{
	double result;
	static BYTE parms[] =
		VTS_R8;
	InvokeHelper(0x46, DISPATCH_METHOD, VT_R8, (void*)&result, parms,
		X);
	return result;
}

long IOldBasic::CloseCommConnection(long port)
{
	long result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x47, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		port);
	return result;
}

long IOldBasic::Flatness(LPCTSTR ID, double out_zone)
{
	long result;
	static BYTE parms[] =
		VTS_BSTR VTS_R8;
	InvokeHelper(0x48, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		ID, out_zone);
	return result;
}

long IOldBasic::GetDimOutTol()
{
	long result;
	InvokeHelper(0x49, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
	return result;
}

long IOldBasic::GetFeatID(long index, BSTR* ID, long Type)
{
	long result;
	static BYTE parms[] =
		VTS_I4 VTS_PBSTR VTS_I4;
	InvokeHelper(0x4a, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		index, ID, Type);
	return result;
}

long IOldBasic::GetFeature(LPCTSTR ID)
{
	long result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x4b, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		ID);
	return result;
}

long IOldBasic::GetPH9Status()
{
	long result;
	InvokeHelper(0x4c, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
	return result;
}

double IOldBasic::GetProbeRadius()
{
	double result;
	InvokeHelper(0x4d, DISPATCH_METHOD, VT_R8, (void*)&result, NULL);
	return result;
}

long IOldBasic::GetProgramOption(long opt)
{
	long result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x4e, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		opt);
	return result;
}

double IOldBasic::GetProgramValue(long opt)
{
	double result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x4f, DISPATCH_METHOD, VT_R8, (void*)&result, parms,
		opt);
	return result;
}

double IOldBasic::GetTopMachineSpeed()
{
	double result;
	InvokeHelper(0x50, DISPATCH_METHOD, VT_R8, (void*)&result, NULL);
	return result;
}

long IOldBasic::GetType(LPCTSTR ID)
{
	long result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x51, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		ID);
	return result;
}

long IOldBasic::GetUnits()
{
	long result;
	InvokeHelper(0x52, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
	return result;
}

long IOldBasic::OpenCommConnection(long port, long baud, long parity, long Data, long stop, long flow)
{
	long result;
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4;
	InvokeHelper(0x53, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		port, baud, parity, Data, stop, flow);
	return result;
}

long IOldBasic::ReadCommBlock(long port, BSTR* buffer, long Count)
{
	long result;
	static BYTE parms[] =
		VTS_I4 VTS_PBSTR VTS_I4;
	InvokeHelper(0x54, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		port, buffer, Count);
	return result;
}

long IOldBasic::Roundness(LPCTSTR ID, double* out_zone)
{
	long result;
	static BYTE parms[] =
		VTS_BSTR VTS_PR8;
	InvokeHelper(0x55, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		ID, out_zone);
	return result;
}

long IOldBasic::StartGetFeatPoint(LPCTSTR ID, long dtype, long XYZ)
{
	long result;
	static BYTE parms[] =
		VTS_BSTR VTS_I4 VTS_I4;
	InvokeHelper(0x56, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		ID, dtype, XYZ);
	return result;
}

long IOldBasic::Straitness(LPCTSTR ID, double* out_zone)
{
	long result;
	static BYTE parms[] =
		VTS_BSTR VTS_PR8;
	InvokeHelper(0x57, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		ID, out_zone);
	return result;
}

long IOldBasic::Workplane(long plane)
{
	long result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x58, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		plane);
	return result;
}

long IOldBasic::WriteCommBlock(long port, LPCTSTR buffer, long Count)
{
	long result;
	static BYTE parms[] =
		VTS_I4 VTS_BSTR VTS_I4;
	InvokeHelper(0x59, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		port, buffer, Count);
	return result;
}

void IOldBasic::GetFeatData(LPCTSTR ID, LPDISPATCH buffer, long dtype, long XYZ, long IJK)
{
	static BYTE parms[] =
		VTS_BSTR VTS_DISPATCH VTS_I4 VTS_I4 VTS_I4;
	InvokeHelper(0x5a, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 ID, buffer, dtype, XYZ, IJK);
}

void IOldBasic::PutFeatData(LPCTSTR ID, LPDISPATCH* buffer, long dtype, long XYZ, long IJK)
{
	static BYTE parms[] =
		VTS_BSTR VTS_PDISPATCH VTS_I4 VTS_I4 VTS_I4;
	InvokeHelper(0x5b, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 ID, buffer, dtype, XYZ, IJK);
}

long IOldBasic::GetFeatPoint(LPDISPATCH* buffer, long index)
{
	long result;
	static BYTE parms[] =
		VTS_PDISPATCH VTS_I4;
	InvokeHelper(0x5c, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		buffer, index);
	return result;
}

void IOldBasic::GetProbeOffsets(LPDISPATCH* buffer)
{
	static BYTE parms[] =
		VTS_PDISPATCH;
	InvokeHelper(0x5d, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 buffer);
}

long IOldBasic::MaxMinAve(LPCTSTR ID, LPDISPATCH* in_vect, double* out_max, double* out_min, double* out_ave)
{
	long result;
	static BYTE parms[] =
		VTS_BSTR VTS_PDISPATCH VTS_PR8 VTS_PR8 VTS_PR8;
	InvokeHelper(0x5e, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		ID, in_vect, out_max, out_min, out_ave);
	return result;
}

long IOldBasic::RunOut(LPCTSTR ID, LPDISPATCH* in_datumxyz, LPDISPATCH* in_datumijk, double* out_zone)
{
	long result;
	static BYTE parms[] =
		VTS_BSTR VTS_PDISPATCH VTS_PDISPATCH VTS_PR8;
	InvokeHelper(0x5f, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		ID, in_datumxyz, in_datumijk, out_zone);
	return result;
}

void IOldBasic::GetDimData(LPCTSTR ID, LPDISPATCH* buffer, long dtype)
{
	static BYTE parms[] =
		VTS_BSTR VTS_PDISPATCH VTS_I4;
	InvokeHelper(0x60, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 ID, buffer, dtype);
}

void IOldBasic::Wait()
{
	InvokeHelper(0x61, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IOldBasic::Sleep(float seconds)
{
	static BYTE parms[] =
		VTS_R4;
	InvokeHelper(0x62, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 seconds);
}


/////////////////////////////////////////////////////////////////////////////
// IFeatData properties

double IFeatData::GetX()
{
	double result;
	GetProperty(0x1, VT_R8, (void*)&result);
	return result;
}

void IFeatData::SetX(double propVal)
{
	SetProperty(0x1, VT_R8, propVal);
}

double IFeatData::GetY()
{
	double result;
	GetProperty(0x2, VT_R8, (void*)&result);
	return result;
}

void IFeatData::SetY(double propVal)
{
	SetProperty(0x2, VT_R8, propVal);
}

double IFeatData::GetZ()
{
	double result;
	GetProperty(0x3, VT_R8, (void*)&result);
	return result;
}

void IFeatData::SetZ(double propVal)
{
	SetProperty(0x3, VT_R8, propVal);
}

double IFeatData::GetI()
{
	double result;
	GetProperty(0x4, VT_R8, (void*)&result);
	return result;
}

void IFeatData::SetI(double propVal)
{
	SetProperty(0x4, VT_R8, propVal);
}

double IFeatData::GetJ()
{
	double result;
	GetProperty(0x5, VT_R8, (void*)&result);
	return result;
}

void IFeatData::SetJ(double propVal)
{
	SetProperty(0x5, VT_R8, propVal);
}

double IFeatData::GetK()
{
	double result;
	GetProperty(0x6, VT_R8, (void*)&result);
	return result;
}

void IFeatData::SetK(double propVal)
{
	SetProperty(0x6, VT_R8, propVal);
}

double IFeatData::GetDiam()
{
	double result;
	GetProperty(0x7, VT_R8, (void*)&result);
	return result;
}

void IFeatData::SetDiam(double propVal)
{
	SetProperty(0x7, VT_R8, propVal);
}

double IFeatData::GetLength()
{
	double result;
	GetProperty(0x8, VT_R8, (void*)&result);
	return result;
}

void IFeatData::SetLength(double propVal)
{
	SetProperty(0x8, VT_R8, propVal);
}

double IFeatData::GetAngle()
{
	double result;
	GetProperty(0x9, VT_R8, (void*)&result);
	return result;
}

void IFeatData::SetAngle(double propVal)
{
	SetProperty(0x9, VT_R8, propVal);
}

double IFeatData::GetSmallDiam()
{
	double result;
	GetProperty(0xa, VT_R8, (void*)&result);
	return result;
}

void IFeatData::SetSmallDiam(double propVal)
{
	SetProperty(0xa, VT_R8, propVal);
}

double IFeatData::GetStartAngle()
{
	double result;
	GetProperty(0xb, VT_R8, (void*)&result);
	return result;
}

void IFeatData::SetStartAngle(double propVal)
{
	SetProperty(0xb, VT_R8, propVal);
}

double IFeatData::GetEndAngle()
{
	double result;
	GetProperty(0xc, VT_R8, (void*)&result);
	return result;
}

void IFeatData::SetEndAngle(double propVal)
{
	SetProperty(0xc, VT_R8, propVal);
}

double IFeatData::GetStartAngle2()
{
	double result;
	GetProperty(0xd, VT_R8, (void*)&result);
	return result;
}

void IFeatData::SetStartAngle2(double propVal)
{
	SetProperty(0xd, VT_R8, propVal);
}

double IFeatData::GetEndAngle2()
{
	double result;
	GetProperty(0xe, VT_R8, (void*)&result);
	return result;
}

void IFeatData::SetEndAngle2(double propVal)
{
	SetProperty(0xe, VT_R8, propVal);
}

double IFeatData::GetF()
{
	double result;
	GetProperty(0xf, VT_R8, (void*)&result);
	return result;
}

void IFeatData::SetF(double propVal)
{
	SetProperty(0xf, VT_R8, propVal);
}

double IFeatData::GetTp()
{
	double result;
	GetProperty(0x10, VT_R8, (void*)&result);
	return result;
}

void IFeatData::SetTp(double propVal)
{
	SetProperty(0x10, VT_R8, propVal);
}

double IFeatData::GetP1()
{
	double result;
	GetProperty(0x11, VT_R8, (void*)&result);
	return result;
}

void IFeatData::SetP1(double propVal)
{
	SetProperty(0x11, VT_R8, propVal);
}

double IFeatData::GetP2()
{
	double result;
	GetProperty(0x12, VT_R8, (void*)&result);
	return result;
}

void IFeatData::SetP2(double propVal)
{
	SetProperty(0x12, VT_R8, propVal);
}

CString IFeatData::GetId()
{
	CString result;
	GetProperty(0x13, VT_BSTR, (void*)&result);
	return result;
}

void IFeatData::SetId(LPCTSTR propVal)
{
	SetProperty(0x13, VT_BSTR, propVal);
}

CString IFeatData::Get_id()
{
	CString result;
	GetProperty(0x0, VT_BSTR, (void*)&result);
	return result;
}

void IFeatData::Set_id(LPCTSTR propVal)
{
	SetProperty(0x0, VT_BSTR, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IFeatData operations


/////////////////////////////////////////////////////////////////////////////
// IDimData properties

double IDimData::GetNom()
{
	double result;
	GetProperty(0x1, VT_R8, (void*)&result);
	return result;
}

void IDimData::SetNom(double propVal)
{
	SetProperty(0x1, VT_R8, propVal);
}

double IDimData::GetPlus()
{
	double result;
	GetProperty(0x2, VT_R8, (void*)&result);
	return result;
}

void IDimData::SetPlus(double propVal)
{
	SetProperty(0x2, VT_R8, propVal);
}

double IDimData::GetMinus()
{
	double result;
	GetProperty(0x3, VT_R8, (void*)&result);
	return result;
}

void IDimData::SetMinus(double propVal)
{
	SetProperty(0x3, VT_R8, propVal);
}

double IDimData::GetMax()
{
	double result;
	GetProperty(0x4, VT_R8, (void*)&result);
	return result;
}

void IDimData::SetMax(double propVal)
{
	SetProperty(0x4, VT_R8, propVal);
}

double IDimData::GetMin()
{
	double result;
	GetProperty(0x5, VT_R8, (void*)&result);
	return result;
}

void IDimData::SetMin(double propVal)
{
	SetProperty(0x5, VT_R8, propVal);
}

double IDimData::GetDev()
{
	double result;
	GetProperty(0x6, VT_R8, (void*)&result);
	return result;
}

void IDimData::SetDev(double propVal)
{
	SetProperty(0x6, VT_R8, propVal);
}

double IDimData::GetOut()
{
	double result;
	GetProperty(0x7, VT_R8, (void*)&result);
	return result;
}

void IDimData::SetOut(double propVal)
{
	SetProperty(0x7, VT_R8, propVal);
}

double IDimData::GetDevAngle()
{
	double result;
	GetProperty(0x8, VT_R8, (void*)&result);
	return result;
}

void IDimData::SetDevAngle(double propVal)
{
	SetProperty(0x8, VT_R8, propVal);
}

double IDimData::GetBonus()
{
	double result;
	GetProperty(0x9, VT_R8, (void*)&result);
	return result;
}

void IDimData::SetBonus(double propVal)
{
	SetProperty(0x9, VT_R8, propVal);
}

double IDimData::GetMeas()
{
	double result;
	GetProperty(0xa, VT_R8, (void*)&result);
	return result;
}

void IDimData::SetMeas(double propVal)
{
	SetProperty(0xa, VT_R8, propVal);
}

double IDimData::Get_Dev()
{
	double result;
	GetProperty(0x0, VT_R8, (void*)&result);
	return result;
}

void IDimData::Set_Dev(double propVal)
{
	SetProperty(0x0, VT_R8, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IDimData operations


/////////////////////////////////////////////////////////////////////////////
// ICadWindows properties

LPDISPATCH ICadWindows::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x1, VT_DISPATCH, (void*)&result);
	return result;
}

void ICadWindows::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x1, VT_DISPATCH, propVal);
}

LPDISPATCH ICadWindows::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x2, VT_DISPATCH, (void*)&result);
	return result;
}

void ICadWindows::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x2, VT_DISPATCH, propVal);
}

long ICadWindows::GetCount()
{
	long result;
	GetProperty(0x3, VT_I4, (void*)&result);
	return result;
}

void ICadWindows::SetCount(long propVal)
{
	SetProperty(0x3, VT_I4, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// ICadWindows operations

LPDISPATCH ICadWindows::Item(LPCTSTR ID)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		ID);
	return result;
}

LPDISPATCH ICadWindows::_Item(LPCTSTR ID)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		ID);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ICadWindow properties

LPDISPATCH ICadWindow::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x1, VT_DISPATCH, (void*)&result);
	return result;
}

void ICadWindow::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x1, VT_DISPATCH, propVal);
}

LPDISPATCH ICadWindow::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x2, VT_DISPATCH, (void*)&result);
	return result;
}

void ICadWindow::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x2, VT_DISPATCH, propVal);
}

BOOL ICadWindow::GetVisible()
{
	BOOL result;
	GetProperty(0x3, VT_BOOL, (void*)&result);
	return result;
}

void ICadWindow::SetVisible(BOOL propVal)
{
	SetProperty(0x3, VT_BOOL, propVal);
}

long ICadWindow::GetLeft()
{
	long result;
	GetProperty(0x4, VT_I4, (void*)&result);
	return result;
}

void ICadWindow::SetLeft(long propVal)
{
	SetProperty(0x4, VT_I4, propVal);
}

long ICadWindow::GetWidth()
{
	long result;
	GetProperty(0x5, VT_I4, (void*)&result);
	return result;
}

void ICadWindow::SetWidth(long propVal)
{
	SetProperty(0x5, VT_I4, propVal);
}

long ICadWindow::GetTop()
{
	long result;
	GetProperty(0x6, VT_I4, (void*)&result);
	return result;
}

void ICadWindow::SetTop(long propVal)
{
	SetProperty(0x6, VT_I4, propVal);
}

long ICadWindow::GetHeight()
{
	long result;
	GetProperty(0x7, VT_I4, (void*)&result);
	return result;
}

void ICadWindow::SetHeight(long propVal)
{
	SetProperty(0x7, VT_I4, propVal);
}

BOOL ICadWindow::Get_Visible()
{
	BOOL result;
	GetProperty(0x0, VT_BOOL, (void*)&result);
	return result;
}

void ICadWindow::Set_Visible(BOOL propVal)
{
	SetProperty(0x0, VT_BOOL, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// ICadWindow operations

BOOL ICadWindow::Print(long Option, BOOL DrawRulers)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4 VTS_BOOL;
	InvokeHelper(0x8, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		Option, DrawRulers);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ITools properties

LPDISPATCH ITools::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x1, VT_DISPATCH, (void*)&result);
	return result;
}

void ITools::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x1, VT_DISPATCH, propVal);
}

LPDISPATCH ITools::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x2, VT_DISPATCH, (void*)&result);
	return result;
}

void ITools::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x2, VT_DISPATCH, propVal);
}

long ITools::GetCount()
{
	long result;
	GetProperty(0x3, VT_I4, (void*)&result);
	return result;
}

void ITools::SetCount(long propVal)
{
	SetProperty(0x3, VT_I4, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// ITools operations

LPDISPATCH ITools::Add(LPCTSTR ID)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		ID);
	return result;
}

BOOL ITools::Remove(LPCTSTR ID)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		ID);
	return result;
}

LPDISPATCH ITools::Item(const VARIANT& ID)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&ID);
	return result;
}

LPDISPATCH ITools::_Item(const VARIANT& ID)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&ID);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ITool properties

double ITool::GetDiam()
{
	double result;
	GetProperty(0x1, VT_R8, (void*)&result);
	return result;
}

void ITool::SetDiam(double propVal)
{
	SetProperty(0x1, VT_R8, propVal);
}

CString ITool::GetId()
{
	CString result;
	GetProperty(0x2, VT_BSTR, (void*)&result);
	return result;
}

void ITool::SetId(LPCTSTR propVal)
{
	SetProperty(0x2, VT_BSTR, propVal);
}

LPDISPATCH ITool::GetShankIJK()
{
	LPDISPATCH result;
	GetProperty(0x3, VT_DISPATCH, (void*)&result);
	return result;
}

void ITool::SetShankIJK(LPDISPATCH propVal)
{
	SetProperty(0x3, VT_DISPATCH, propVal);
}

long ITool::GetToolType()
{
	long result;
	GetProperty(0x4, VT_I4, (void*)&result);
	return result;
}

void ITool::SetToolType(long propVal)
{
	SetProperty(0x4, VT_I4, propVal);
}

double ITool::GetWidth()
{
	double result;
	GetProperty(0x5, VT_R8, (void*)&result);
	return result;
}

void ITool::SetWidth(double propVal)
{
	SetProperty(0x5, VT_R8, propVal);
}

LPDISPATCH ITool::GetXyz()
{
	LPDISPATCH result;
	GetProperty(0x6, VT_DISPATCH, (void*)&result);
	return result;
}

void ITool::SetXyz(LPDISPATCH propVal)
{
	SetProperty(0x6, VT_DISPATCH, propVal);
}

LPDISPATCH ITool::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x7, VT_DISPATCH, (void*)&result);
	return result;
}

void ITool::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x7, VT_DISPATCH, propVal);
}

LPDISPATCH ITool::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x8, VT_DISPATCH, (void*)&result);
	return result;
}

void ITool::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x8, VT_DISPATCH, propVal);
}

CString ITool::Get_id()
{
	CString result;
	GetProperty(0x0, VT_BSTR, (void*)&result);
	return result;
}

void ITool::Set_id(LPCTSTR propVal)
{
	SetProperty(0x0, VT_BSTR, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// ITool operations


/////////////////////////////////////////////////////////////////////////////
// IProbes properties

LPDISPATCH IProbes::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x1, VT_DISPATCH, (void*)&result);
	return result;
}

void IProbes::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x1, VT_DISPATCH, propVal);
}

long IProbes::GetCount()
{
	long result;
	GetProperty(0x2, VT_I4, (void*)&result);
	return result;
}

void IProbes::SetCount(long propVal)
{
	SetProperty(0x2, VT_I4, propVal);
}

LPDISPATCH IProbes::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x3, VT_DISPATCH, (void*)&result);
	return result;
}

void IProbes::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x3, VT_DISPATCH, propVal);
}

BOOL IProbes::GetVisible()
{
	BOOL result;
	GetProperty(0x9, VT_BOOL, (void*)&result);
	return result;
}

void IProbes::SetVisible(BOOL propVal)
{
	SetProperty(0x9, VT_BOOL, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IProbes operations

BOOL IProbes::Add(LPCTSTR filename)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		filename);
	return result;
}

LPDISPATCH IProbes::Item(const VARIANT& NameorNum)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&NameorNum);
	return result;
}

void IProbes::SaveChanges()
{
	InvokeHelper(0x7, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IProbes::CancelChanges()
{
	InvokeHelper(0x8, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IProbes::_Item(const VARIANT& NameorNum)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&NameorNum);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IProbe properties

LPDISPATCH IProbe::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x1, VT_DISPATCH, (void*)&result);
	return result;
}

void IProbe::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x1, VT_DISPATCH, propVal);
}

CString IProbe::GetFullName()
{
	CString result;
	GetProperty(0x2, VT_BSTR, (void*)&result);
	return result;
}

void IProbe::SetFullName(LPCTSTR propVal)
{
	SetProperty(0x2, VT_BSTR, propVal);
}

CString IProbe::GetName()
{
	CString result;
	GetProperty(0x3, VT_BSTR, (void*)&result);
	return result;
}

void IProbe::SetName(LPCTSTR propVal)
{
	SetProperty(0x3, VT_BSTR, propVal);
}

LPDISPATCH IProbe::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x4, VT_DISPATCH, (void*)&result);
	return result;
}

void IProbe::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x4, VT_DISPATCH, propVal);
}

CString IProbe::GetPath()
{
	CString result;
	GetProperty(0x5, VT_BSTR, (void*)&result);
	return result;
}

void IProbe::SetPath(LPCTSTR propVal)
{
	SetProperty(0x5, VT_BSTR, propVal);
}

LPDISPATCH IProbe::GetTips()
{
	LPDISPATCH result;
	GetProperty(0x6, VT_DISPATCH, (void*)&result);
	return result;
}

void IProbe::SetTips(LPDISPATCH propVal)
{
	SetProperty(0x6, VT_DISPATCH, propVal);
}

long IProbe::GetConnectionCount()
{
	long result;
	GetProperty(0x7, VT_I4, (void*)&result);
	return result;
}

void IProbe::SetConnectionCount(long propVal)
{
	SetProperty(0x7, VT_I4, propVal);
}

long IProbe::GetComponentCount()
{
	long result;
	GetProperty(0x8, VT_I4, (void*)&result);
	return result;
}

void IProbe::SetComponentCount(long propVal)
{
	SetProperty(0x8, VT_I4, propVal);
}

long IProbe::GetActiveComponent()
{
	long result;
	GetProperty(0x9, VT_I4, (void*)&result);
	return result;
}

void IProbe::SetActiveComponent(long propVal)
{
	SetProperty(0x9, VT_I4, propVal);
}

long IProbe::GetActiveConnection()
{
	long result;
	GetProperty(0xa, VT_I4, (void*)&result);
	return result;
}

void IProbe::SetActiveConnection(long propVal)
{
	SetProperty(0xa, VT_I4, propVal);
}

LPDISPATCH IProbe::GetQualificationSettings()
{
	LPDISPATCH result;
	GetProperty(0x12, VT_DISPATCH, (void*)&result);
	return result;
}

void IProbe::SetQualificationSettings(LPDISPATCH propVal)
{
	SetProperty(0x12, VT_DISPATCH, propVal);
}

BOOL IProbe::GetUseWristMap()
{
	BOOL result;
	GetProperty(0x13, VT_BOOL, (void*)&result);
	return result;
}

void IProbe::SetUseWristMap(BOOL propVal)
{
	SetProperty(0x13, VT_BOOL, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IProbe operations

void IProbe::Qualify()
{
	InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL IProbe::Dialog()
{
	BOOL result;
	InvokeHelper(0xc, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
	return result;
}

CString IProbe::ConnectionDescription(long Item)
{
	CString result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0xd, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
		Item);
	return result;
}

CString IProbe::ComponentDescription(long Item)
{
	CString result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0xe, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
		Item);
	return result;
}

void IProbe::SelectAllTips()
{
	InvokeHelper(0xf, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IProbe::ClearAllTips()
{
	InvokeHelper(0x10, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL IProbe::Qualify2(LPDISPATCH Settings)
{
	BOOL result;
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x11, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		Settings);
	return result;
}

void IProbe::ResetMeasToTheoForTips()
{
	InvokeHelper(0x14, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// ITips properties

long ITips::GetCount()
{
	long result;
	GetProperty(0x1, VT_I4, (void*)&result);
	return result;
}

void ITips::SetCount(long propVal)
{
	SetProperty(0x1, VT_I4, propVal);
}

LPDISPATCH ITips::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x2, VT_DISPATCH, (void*)&result);
	return result;
}

void ITips::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x2, VT_DISPATCH, propVal);
}

LPDISPATCH ITips::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x3, VT_DISPATCH, (void*)&result);
	return result;
}

void ITips::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x3, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// ITips operations

LPDISPATCH ITips::Item(const VARIANT& NameorNum)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&NameorNum);
	return result;
}

void ITips::Remove(long Num)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Num);
}

long ITips::Add(double a, double b)
{
	long result;
	static BYTE parms[] =
		VTS_R8 VTS_R8;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		a, b);
	return result;
}

LPDISPATCH ITips::_Item(const VARIANT& NameorNum)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&NameorNum);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ITip properties

double ITip::GetA()
{
	double result;
	GetProperty(0x1, VT_R8, (void*)&result);
	return result;
}

void ITip::SetA(double propVal)
{
	SetProperty(0x1, VT_R8, propVal);
}

double ITip::GetB()
{
	double result;
	GetProperty(0x2, VT_R8, (void*)&result);
	return result;
}

void ITip::SetB(double propVal)
{
	SetProperty(0x2, VT_R8, propVal);
}

double ITip::GetDiam()
{
	double result;
	GetProperty(0x3, VT_R8, (void*)&result);
	return result;
}

void ITip::SetDiam(double propVal)
{
	SetProperty(0x3, VT_R8, propVal);
}

CString ITip::GetDate()
{
	CString result;
	GetProperty(0x4, VT_BSTR, (void*)&result);
	return result;
}

void ITip::SetDate(LPCTSTR propVal)
{
	SetProperty(0x4, VT_BSTR, propVal);
}

CString ITip::GetId()
{
	CString result;
	GetProperty(0x5, VT_BSTR, (void*)&result);
	return result;
}

void ITip::SetId(LPCTSTR propVal)
{
	SetProperty(0x5, VT_BSTR, propVal);
}

LPDISPATCH ITip::GetIjk()
{
	LPDISPATCH result;
	GetProperty(0x6, VT_DISPATCH, (void*)&result);
	return result;
}

void ITip::SetIjk(LPDISPATCH propVal)
{
	SetProperty(0x6, VT_DISPATCH, propVal);
}

LPDISPATCH ITip::GetMeasXYZ()
{
	LPDISPATCH result;
	GetProperty(0x7, VT_DISPATCH, (void*)&result);
	return result;
}

void ITip::SetMeasXYZ(LPDISPATCH propVal)
{
	SetProperty(0x7, VT_DISPATCH, propVal);
}

double ITip::GetMeasDiam()
{
	double result;
	GetProperty(0x8, VT_R8, (void*)&result);
	return result;
}

void ITip::SetMeasDiam(double propVal)
{
	SetProperty(0x8, VT_R8, propVal);
}

double ITip::GetStandardDeviation()
{
	double result;
	GetProperty(0x9, VT_R8, (void*)&result);
	return result;
}

void ITip::SetStandardDeviation(double propVal)
{
	SetProperty(0x9, VT_R8, propVal);
}

double ITip::GetPrbRdv()
{
	double result;
	GetProperty(0xa, VT_R8, (void*)&result);
	return result;
}

void ITip::SetPrbRdv(double propVal)
{
	SetProperty(0xa, VT_R8, propVal);
}

LPDISPATCH ITip::GetParent()
{
	LPDISPATCH result;
	GetProperty(0xb, VT_DISPATCH, (void*)&result);
	return result;
}

void ITip::SetParent(LPDISPATCH propVal)
{
	SetProperty(0xb, VT_DISPATCH, propVal);
}

CString ITip::GetTime()
{
	CString result;
	GetProperty(0xc, VT_BSTR, (void*)&result);
	return result;
}

void ITip::SetTime(LPCTSTR propVal)
{
	SetProperty(0xc, VT_BSTR, propVal);
}

long ITip::GetTipNum()
{
	long result;
	GetProperty(0xd, VT_I4, (void*)&result);
	return result;
}

void ITip::SetTipNum(long propVal)
{
	SetProperty(0xd, VT_I4, propVal);
}

long ITip::GetTipType()
{
	long result;
	GetProperty(0xe, VT_I4, (void*)&result);
	return result;
}

void ITip::SetTipType(long propVal)
{
	SetProperty(0xe, VT_I4, propVal);
}

double ITip::GetThickness()
{
	double result;
	GetProperty(0xf, VT_R8, (void*)&result);
	return result;
}

void ITip::SetThickness(double propVal)
{
	SetProperty(0xf, VT_R8, propVal);
}

double ITip::GetMeasThickness()
{
	double result;
	GetProperty(0x10, VT_R8, (void*)&result);
	return result;
}

void ITip::SetMeasThickness(double propVal)
{
	SetProperty(0x10, VT_R8, propVal);
}

LPDISPATCH ITip::GetWristOffset()
{
	LPDISPATCH result;
	GetProperty(0x11, VT_DISPATCH, (void*)&result);
	return result;
}

void ITip::SetWristOffset(LPDISPATCH propVal)
{
	SetProperty(0x11, VT_DISPATCH, propVal);
}

LPDISPATCH ITip::GetWristTipIJK()
{
	LPDISPATCH result;
	GetProperty(0x12, VT_DISPATCH, (void*)&result);
	return result;
}

void ITip::SetWristTipIJK(LPDISPATCH propVal)
{
	SetProperty(0x12, VT_DISPATCH, propVal);
}

LPDISPATCH ITip::GetXyz()
{
	LPDISPATCH result;
	GetProperty(0x13, VT_DISPATCH, (void*)&result);
	return result;
}

void ITip::SetXyz(LPDISPATCH propVal)
{
	SetProperty(0x13, VT_DISPATCH, propVal);
}

BOOL ITip::GetSelected()
{
	BOOL result;
	GetProperty(0x14, VT_BOOL, (void*)&result);
	return result;
}

void ITip::SetSelected(BOOL propVal)
{
	SetProperty(0x14, VT_BOOL, propVal);
}

double ITip::GetC()
{
	double result;
	GetProperty(0x15, VT_R8, (void*)&result);
	return result;
}

void ITip::SetC(double propVal)
{
	SetProperty(0x15, VT_R8, propVal);
}

CString ITip::GetNickname()
{
	CString result;
	GetProperty(0x16, VT_BSTR, (void*)&result);
	return result;
}

void ITip::SetNickname(LPCTSTR propVal)
{
	SetProperty(0x16, VT_BSTR, propVal);
}

CString ITip::GetDMISLabel()
{
	CString result;
	GetProperty(0x18, VT_BSTR, (void*)&result);
	return result;
}

void ITip::SetDMISLabel(LPCTSTR propVal)
{
	SetProperty(0x18, VT_BSTR, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// ITip operations

void ITip::ResetMeasToTheo()
{
	InvokeHelper(0x17, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// IQualificationSettings properties

long IQualificationSettings::GetMode()
{
	long result;
	GetProperty(0x1, VT_I4, (void*)&result);
	return result;
}

void IQualificationSettings::SetMode(long propVal)
{
	SetProperty(0x1, VT_I4, propVal);
}

double IQualificationSettings::GetMoveSpeed()
{
	double result;
	GetProperty(0x2, VT_R8, (void*)&result);
	return result;
}

void IQualificationSettings::SetMoveSpeed(double propVal)
{
	SetProperty(0x2, VT_R8, propVal);
}

long IQualificationSettings::GetNumHits()
{
	long result;
	GetProperty(0x3, VT_I4, (void*)&result);
	return result;
}

void IQualificationSettings::SetNumHits(long propVal)
{
	SetProperty(0x3, VT_I4, propVal);
}

double IQualificationSettings::GetPreHit()
{
	double result;
	GetProperty(0x4, VT_R8, (void*)&result);
	return result;
}

void IQualificationSettings::SetPreHit(double propVal)
{
	SetProperty(0x4, VT_R8, propVal);
}

double IQualificationSettings::GetTouchspeed()
{
	double result;
	GetProperty(0x5, VT_R8, (void*)&result);
	return result;
}

void IQualificationSettings::SetTouchspeed(double propVal)
{
	SetProperty(0x5, VT_R8, propVal);
}

BOOL IQualificationSettings::GetShankCheck()
{
	BOOL result;
	GetProperty(0x6, VT_BOOL, (void*)&result);
	return result;
}

void IQualificationSettings::SetShankCheck(BOOL propVal)
{
	SetProperty(0x6, VT_BOOL, propVal);
}

double IQualificationSettings::GetShankOffset()
{
	double result;
	GetProperty(0x7, VT_R8, (void*)&result);
	return result;
}

void IQualificationSettings::SetShankOffset(double propVal)
{
	SetProperty(0x7, VT_R8, propVal);
}

long IQualificationSettings::GetShankHits()
{
	long result;
	GetProperty(0x8, VT_I4, (void*)&result);
	return result;
}

void IQualificationSettings::SetShankHits(long propVal)
{
	SetProperty(0x8, VT_I4, propVal);
}

BOOL IQualificationSettings::GetUserDefinedCalibrationMode()
{
	BOOL result;
	GetProperty(0x9, VT_BOOL, (void*)&result);
	return result;
}

void IQualificationSettings::SetUserDefinedCalibrationMode(BOOL propVal)
{
	SetProperty(0x9, VT_BOOL, propVal);
}

double IQualificationSettings::GetEndAngle()
{
	double result;
	GetProperty(0xa, VT_R8, (void*)&result);
	return result;
}

void IQualificationSettings::SetEndAngle(double propVal)
{
	SetProperty(0xa, VT_R8, propVal);
}

double IQualificationSettings::GetStartAngle()
{
	double result;
	GetProperty(0xb, VT_R8, (void*)&result);
	return result;
}

void IQualificationSettings::SetStartAngle(double propVal)
{
	SetProperty(0xb, VT_R8, propVal);
}

long IQualificationSettings::GetNumLevels()
{
	long result;
	GetProperty(0xc, VT_I4, (void*)&result);
	return result;
}

void IQualificationSettings::SetNumLevels(long propVal)
{
	SetProperty(0xc, VT_I4, propVal);
}

BOOL IQualificationSettings::GetUserDefinedCalibrationOrder()
{
	BOOL result;
	GetProperty(0xd, VT_BOOL, (void*)&result);
	return result;
}

void IQualificationSettings::SetUserDefinedCalibrationOrder(BOOL propVal)
{
	SetProperty(0xd, VT_BOOL, propVal);
}

double IQualificationSettings::GetToolOverideI()
{
	double result;
	GetProperty(0xe, VT_R8, (void*)&result);
	return result;
}

void IQualificationSettings::SetToolOverideI(double propVal)
{
	SetProperty(0xe, VT_R8, propVal);
}

double IQualificationSettings::GetToolOverideJ()
{
	double result;
	GetProperty(0xf, VT_R8, (void*)&result);
	return result;
}

void IQualificationSettings::SetToolOverideJ(double propVal)
{
	SetProperty(0xf, VT_R8, propVal);
}

double IQualificationSettings::GetToolOverideK()
{
	double result;
	GetProperty(0x10, VT_R8, (void*)&result);
	return result;
}

void IQualificationSettings::SetToolOverideK(double propVal)
{
	SetProperty(0x10, VT_R8, propVal);
}

BOOL IQualificationSettings::GetToolOnRotaryTable()
{
	BOOL result;
	GetProperty(0x11, VT_BOOL, (void*)&result);
	return result;
}

void IQualificationSettings::SetToolOnRotaryTable(BOOL propVal)
{
	SetProperty(0x11, VT_BOOL, propVal);
}

BOOL IQualificationSettings::GetPHSAPriority()
{
	BOOL result;
	GetProperty(0x12, VT_BOOL, (void*)&result);
	return result;
}

void IQualificationSettings::SetPHSAPriority(BOOL propVal)
{
	SetProperty(0x12, VT_BOOL, propVal);
}

double IQualificationSettings::GetPHSTol()
{
	double result;
	GetProperty(0x13, VT_R8, (void*)&result);
	return result;
}

void IQualificationSettings::SetPHSTol(double propVal)
{
	SetProperty(0x13, VT_R8, propVal);
}

long IQualificationSettings::GetExecuteMode()
{
	long result;
	GetProperty(0x14, VT_I4, (void*)&result);
	return result;
}

void IQualificationSettings::SetExecuteMode(long propVal)
{
	SetProperty(0x14, VT_I4, propVal);
}

long IQualificationSettings::GetToolMoved()
{
	long result;
	GetProperty(0x15, VT_I4, (void*)&result);
	return result;
}

void IQualificationSettings::SetToolMoved(long propVal)
{
	SetProperty(0x15, VT_I4, propVal);
}

long IQualificationSettings::GetCreateReplaceMap()
{
	long result;
	GetProperty(0x18, VT_I4, (void*)&result);
	return result;
}

void IQualificationSettings::SetCreateReplaceMap(long propVal)
{
	SetProperty(0x18, VT_I4, propVal);
}

double IQualificationSettings::GetStartA()
{
	double result;
	GetProperty(0x19, VT_R8, (void*)&result);
	return result;
}

void IQualificationSettings::SetStartA(double propVal)
{
	SetProperty(0x19, VT_R8, propVal);
}

double IQualificationSettings::GetEndA()
{
	double result;
	GetProperty(0x1a, VT_R8, (void*)&result);
	return result;
}

void IQualificationSettings::SetEndA(double propVal)
{
	SetProperty(0x1a, VT_R8, propVal);
}

double IQualificationSettings::GetIncrementA()
{
	double result;
	GetProperty(0x1b, VT_R8, (void*)&result);
	return result;
}

void IQualificationSettings::SetIncrementA(double propVal)
{
	SetProperty(0x1b, VT_R8, propVal);
}

double IQualificationSettings::GetStartB()
{
	double result;
	GetProperty(0x1c, VT_R8, (void*)&result);
	return result;
}

void IQualificationSettings::SetStartB(double propVal)
{
	SetProperty(0x1c, VT_R8, propVal);
}

double IQualificationSettings::GetEndB()
{
	double result;
	GetProperty(0x1d, VT_R8, (void*)&result);
	return result;
}

void IQualificationSettings::SetEndB(double propVal)
{
	SetProperty(0x1d, VT_R8, propVal);
}

double IQualificationSettings::GetIncrementB()
{
	double result;
	GetProperty(0x1e, VT_R8, (void*)&result);
	return result;
}

void IQualificationSettings::SetIncrementB(double propVal)
{
	SetProperty(0x1e, VT_R8, propVal);
}

double IQualificationSettings::GetStartC()
{
	double result;
	GetProperty(0x1f, VT_R8, (void*)&result);
	return result;
}

void IQualificationSettings::SetStartC(double propVal)
{
	SetProperty(0x1f, VT_R8, propVal);
}

double IQualificationSettings::GetEndC()
{
	double result;
	GetProperty(0x20, VT_R8, (void*)&result);
	return result;
}

void IQualificationSettings::SetEndC(double propVal)
{
	SetProperty(0x20, VT_R8, propVal);
}

double IQualificationSettings::GetIncrementC()
{
	double result;
	GetProperty(0x21, VT_R8, (void*)&result);
	return result;
}

void IQualificationSettings::SetIncrementC(double propVal)
{
	SetProperty(0x21, VT_R8, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IQualificationSettings operations

LPDISPATCH IQualificationSettings::GetTool()
{
	LPDISPATCH result;
	InvokeHelper(0x16, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

BOOL IQualificationSettings::SetTool(LPDISPATCH tool)
{
	BOOL result;
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x17, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		tool);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IMachine properties

CString IMachine::GetName()
{
	CString result;
	GetProperty(0x1, VT_BSTR, (void*)&result);
	return result;
}

void IMachine::SetName(LPCTSTR propVal)
{
	SetProperty(0x1, VT_BSTR, propVal);
}

LPDISPATCH IMachine::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x2, VT_DISPATCH, (void*)&result);
	return result;
}

void IMachine::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x2, VT_DISPATCH, propVal);
}

LPDISPATCH IMachine::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x3, VT_DISPATCH, (void*)&result);
	return result;
}

void IMachine::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x3, VT_DISPATCH, propVal);
}

BOOL IMachine::GetIsFPanel()
{
	BOOL result;
	GetProperty(0x4, VT_BOOL, (void*)&result);
	return result;
}

void IMachine::SetIsFPanel(BOOL propVal)
{
	SetProperty(0x4, VT_BOOL, propVal);
}

LPDISPATCH IMachine::GetFPanel()
{
	LPDISPATCH result;
	GetProperty(0x5, VT_DISPATCH, (void*)&result);
	return result;
}

void IMachine::SetFPanel(LPDISPATCH propVal)
{
	SetProperty(0x5, VT_DISPATCH, propVal);
}

LPDISPATCH IMachine::GetProbePosition()
{
	LPDISPATCH result;
	GetProperty(0x8, VT_DISPATCH, (void*)&result);
	return result;
}

void IMachine::SetProbePosition(LPDISPATCH propVal)
{
	SetProperty(0x8, VT_DISPATCH, propVal);
}

long IMachine::GetManAutoSelector()
{
	long result;
	GetProperty(0x9, VT_I4, (void*)&result);
	return result;
}

void IMachine::SetManAutoSelector(long propVal)
{
	SetProperty(0x9, VT_I4, propVal);
}

CString IMachine::Get_Name()
{
	CString result;
	GetProperty(0x0, VT_BSTR, (void*)&result);
	return result;
}

void IMachine::Set_Name(LPCTSTR propVal)
{
	SetProperty(0x0, VT_BSTR, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IMachine operations

LPDISPATCH IMachine::GetArray()
{
	LPDISPATCH result;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

BOOL IMachine::ExecuteCustomCommand(long CommandNumber, LPDISPATCH InputIntArray, LPDISPATCH InputDoubleArray, LPDISPATCH OutputIntArray, LPDISPATCH OutputDoubleArray)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4 VTS_DISPATCH VTS_DISPATCH VTS_DISPATCH VTS_DISPATCH;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		CommandNumber, InputIntArray, InputDoubleArray, OutputIntArray, OutputDoubleArray);
	return result;
}

void IMachine::InsertMovePoint()
{
	InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IMachine::DeletePoint()
{
	InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IMachine::PressDone()
{
	InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// IMachines properties

LPDISPATCH IMachines::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x1, VT_DISPATCH, (void*)&result);
	return result;
}

void IMachines::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x1, VT_DISPATCH, propVal);
}

LPDISPATCH IMachines::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x2, VT_DISPATCH, (void*)&result);
	return result;
}

void IMachines::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x2, VT_DISPATCH, propVal);
}

short IMachines::GetCount()
{
	short result;
	GetProperty(0x3, VT_I2, (void*)&result);
	return result;
}

void IMachines::SetCount(short propVal)
{
	SetProperty(0x3, VT_I2, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IMachines operations

LPDISPATCH IMachines::Item(const VARIANT& NameorNum)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&NameorNum);
	return result;
}

LPDISPATCH IMachines::_Item(const VARIANT& NameorNum)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&NameorNum);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IFPanel properties

LPDISPATCH IFPanel::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x1, VT_DISPATCH, (void*)&result);
	return result;
}

void IFPanel::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x1, VT_DISPATCH, propVal);
}

long IFPanel::GetPanelSelector()
{
	long result;
	GetProperty(0x2, VT_I4, (void*)&result);
	return result;
}

void IFPanel::SetPanelSelector(long propVal)
{
	SetProperty(0x2, VT_I4, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IFPanel operations


/////////////////////////////////////////////////////////////////////////////
// IArray properties

/////////////////////////////////////////////////////////////////////////////
// IArray operations

void IArray::SetSize(long NewSize)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x1, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 NewSize);
}

void IArray::SetValue(long ArrayPosition, double NewValue)
{
	static BYTE parms[] =
		VTS_I4 VTS_R8;
	InvokeHelper(0x2, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 ArrayPosition, NewValue);
}

double IArray::GetValue(long ArrayPosition)
{
	double result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x3, DISPATCH_METHOD, VT_R8, (void*)&result, parms,
		ArrayPosition);
	return result;
}

long IArray::GetSize()
{
	long result;
	InvokeHelper(0x4, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IMasterSlaveDialog properties

LPDISPATCH IMasterSlaveDialog::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x1, VT_DISPATCH, (void*)&result);
	return result;
}

void IMasterSlaveDialog::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x1, VT_DISPATCH, propVal);
}

LPDISPATCH IMasterSlaveDialog::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x2, VT_DISPATCH, (void*)&result);
	return result;
}

void IMasterSlaveDialog::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x2, VT_DISPATCH, propVal);
}

long IMasterSlaveDialog::GetMeasuringArm()
{
	long result;
	GetProperty(0x3, VT_I4, (void*)&result);
	return result;
}

void IMasterSlaveDialog::SetMeasuringArm(long propVal)
{
	SetProperty(0x3, VT_I4, propVal);
}

long IMasterSlaveDialog::GetDcc()
{
	long result;
	GetProperty(0x4, VT_I4, (void*)&result);
	return result;
}

void IMasterSlaveDialog::SetDcc(long propVal)
{
	SetProperty(0x4, VT_I4, propVal);
}

LPDISPATCH IMasterSlaveDialog::GetPosition()
{
	LPDISPATCH result;
	GetProperty(0x5, VT_DISPATCH, (void*)&result);
	return result;
}

void IMasterSlaveDialog::SetPosition(LPDISPATCH propVal)
{
	SetProperty(0x5, VT_DISPATCH, propVal);
}

CString IMasterSlaveDialog::GetMasterProbe()
{
	CString result;
	GetProperty(0x6, VT_BSTR, (void*)&result);
	return result;
}

void IMasterSlaveDialog::SetMasterProbe(LPCTSTR propVal)
{
	SetProperty(0x6, VT_BSTR, propVal);
}

CString IMasterSlaveDialog::GetMasterTip()
{
	CString result;
	GetProperty(0x7, VT_BSTR, (void*)&result);
	return result;
}

void IMasterSlaveDialog::SetMasterTip(LPCTSTR propVal)
{
	SetProperty(0x7, VT_BSTR, propVal);
}

CString IMasterSlaveDialog::GetSlaveProbe()
{
	CString result;
	GetProperty(0x8, VT_BSTR, (void*)&result);
	return result;
}

void IMasterSlaveDialog::SetSlaveProbe(LPCTSTR propVal)
{
	SetProperty(0x8, VT_BSTR, propVal);
}

CString IMasterSlaveDialog::GetSlaveTip()
{
	CString result;
	GetProperty(0x9, VT_BSTR, (void*)&result);
	return result;
}

void IMasterSlaveDialog::SetSlaveTip(LPCTSTR propVal)
{
	SetProperty(0x9, VT_BSTR, propVal);
}

CString IMasterSlaveDialog::GetTool()
{
	CString result;
	GetProperty(0xa, VT_BSTR, (void*)&result);
	return result;
}

void IMasterSlaveDialog::SetTool(LPCTSTR propVal)
{
	SetProperty(0xa, VT_BSTR, propVal);
}

BOOL IMasterSlaveDialog::GetVisible()
{
	BOOL result;
	GetProperty(0xc, VT_BOOL, (void*)&result);
	return result;
}

void IMasterSlaveDialog::SetVisible(BOOL propVal)
{
	SetProperty(0xc, VT_BOOL, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IMasterSlaveDialog operations

long IMasterSlaveDialog::Calibrate()
{
	long result;
	InvokeHelper(0xb, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ICadModel properties

LPDISPATCH ICadModel::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x5, VT_DISPATCH, (void*)&result);
	return result;
}

void ICadModel::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x5, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// ICadModel operations

BOOL ICadModel::HighlightElement(LPCTSTR Name, BOOL All)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR VTS_BOOL;
	InvokeHelper(0x1, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		Name, All);
	return result;
}

BOOL ICadModel::UnHighlightElement(LPCTSTR Name, BOOL All)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR VTS_BOOL;
	InvokeHelper(0x2, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		Name, All);
	return result;
}

LPDISPATCH ICadModel::CADSlice(double PlaneAnchorX, double PlaneAnchorY, double PlaneAnchorZ, double PlaneVectorI, double PlaneVectorJ, double PlaneVectorK, double Tolerance)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0x3, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		PlaneAnchorX, PlaneAnchorY, PlaneAnchorZ, PlaneVectorI, PlaneVectorJ, PlaneVectorK, Tolerance);
	return result;
}

LPDISPATCH ICadModel::CadCollectionSlice(long CADType, double PlaneAnchorX, double PlaneAnchorY, double PlaneAnchorZ, double PlaneVectorI, double PlaneVectorJ, double PlaneVectorK, double Tolerance)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4 VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0x4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		CADType, PlaneAnchorX, PlaneAnchorY, PlaneAnchorZ, PlaneVectorI, PlaneVectorJ, PlaneVectorK, Tolerance);
	return result;
}

BOOL ICadModel::ScaleToFit(LPDISPATCH Command)
{
	BOOL result;
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		Command);
	return result;
}

long ICadModel::CADProjectPoint(double pointX, double pointY, double pointZ, long geometryFilterFlags, long vectorOption, long surfaceBoundaryOption, double* pProjectPointX, double* pProjectPointY, double* pProjectPointZ, double* pProjectVectorI, 
		double* pProjectVectorJ, double* pProjectVectorK, LPDISPATCH pCadHandle)
{
	long result;
	static BYTE parms[] =
		VTS_R8 VTS_R8 VTS_R8 VTS_I4 VTS_I4 VTS_I4 VTS_PR8 VTS_PR8 VTS_PR8 VTS_PR8 VTS_PR8 VTS_PR8 VTS_DISPATCH;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		pointX, pointY, pointZ, geometryFilterFlags, vectorOption, surfaceBoundaryOption, pProjectPointX, pProjectPointY, pProjectPointZ, pProjectVectorI, pProjectVectorJ, pProjectVectorK, pCadHandle);
	return result;
}

LPDISPATCH ICadModel::GetEmptyCadHandle()
{
	LPDISPATCH result;
	InvokeHelper(0x8, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

long ICadModel::CADIntersectLine(double linePointX, double linePointY, double linePointZ, double lineVectorI, double lineVectorJ, double lineVectorK, long geometryFilterFlags, long vectorOption, long surfaceBoundaryOption, long lineIntersectFlags, 
		double* pIntersectPointX, double* pIntersectPointY, double* pIntersectPointZ, double* pIntersectVectorI, double* pIntersectVectorJ, double* pIntersectVectorK, LPDISPATCH pCadHandle)
{
	long result;
	static BYTE parms[] =
		VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_PR8 VTS_PR8 VTS_PR8 VTS_PR8 VTS_PR8 VTS_PR8 VTS_DISPATCH;
	InvokeHelper(0x9, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		linePointX, linePointY, linePointZ, lineVectorI, lineVectorJ, lineVectorK, geometryFilterFlags, vectorOption, surfaceBoundaryOption, lineIntersectFlags, pIntersectPointX, pIntersectPointY, pIntersectPointZ, pIntersectVectorI, 
		pIntersectVectorJ, pIntersectVectorK, pCadHandle);
	return result;
}

long ICadModel::CADIntersectPlane(double planePointX, double planePointY, double planePointZ, double PlaneVectorI, double PlaneVectorJ, double PlaneVectorK, long geometryFilterFlags, long vectorOption, long surfaceBoundaryOption, 
		double* pIntersectPointX, double* pIntersectPointY, double* pIntersectPointZ, double* pIntersectVectorI, double* pIntersectVectorJ, double* pIntersectVectorK, LPDISPATCH pCadHandle)
{
	long result;
	static BYTE parms[] =
		VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_I4 VTS_I4 VTS_I4 VTS_PR8 VTS_PR8 VTS_PR8 VTS_PR8 VTS_PR8 VTS_PR8 VTS_DISPATCH;
	InvokeHelper(0xa, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		planePointX, planePointY, planePointZ, PlaneVectorI, PlaneVectorJ, PlaneVectorK, geometryFilterFlags, vectorOption, surfaceBoundaryOption, pIntersectPointX, pIntersectPointY, pIntersectPointZ, pIntersectVectorI, pIntersectVectorJ, 
		pIntersectVectorK, pCadHandle);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ICadPolyLinesOnSurface properties

LPDISPATCH ICadPolyLinesOnSurface::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x1, VT_DISPATCH, (void*)&result);
	return result;
}

void ICadPolyLinesOnSurface::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x1, VT_DISPATCH, propVal);
}

long ICadPolyLinesOnSurface::GetCount()
{
	long result;
	GetProperty(0x2, VT_I4, (void*)&result);
	return result;
}

void ICadPolyLinesOnSurface::SetCount(long propVal)
{
	SetProperty(0x2, VT_I4, propVal);
}

LPDISPATCH ICadPolyLinesOnSurface::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x5, VT_DISPATCH, (void*)&result);
	return result;
}

void ICadPolyLinesOnSurface::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x5, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// ICadPolyLinesOnSurface operations

LPDISPATCH ICadPolyLinesOnSurface::Item(long Num)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Num);
	return result;
}

LPDISPATCH ICadPolyLinesOnSurface::_Item(long Num)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Num);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ICadPolyLineOnSurface properties

LPDISPATCH ICadPolyLineOnSurface::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x1, VT_DISPATCH, (void*)&result);
	return result;
}

void ICadPolyLineOnSurface::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x1, VT_DISPATCH, propVal);
}

LPDISPATCH ICadPolyLineOnSurface::GetCadPoints()
{
	LPDISPATCH result;
	GetProperty(0x2, VT_DISPATCH, (void*)&result);
	return result;
}

void ICadPolyLineOnSurface::SetCadPoints(LPDISPATCH propVal)
{
	SetProperty(0x2, VT_DISPATCH, propVal);
}

BOOL ICadPolyLineOnSurface::GetClosed()
{
	BOOL result;
	GetProperty(0x3, VT_BOOL, (void*)&result);
	return result;
}

void ICadPolyLineOnSurface::SetClosed(BOOL propVal)
{
	SetProperty(0x3, VT_BOOL, propVal);
}

LPDISPATCH ICadPolyLineOnSurface::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x4, VT_DISPATCH, (void*)&result);
	return result;
}

void ICadPolyLineOnSurface::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x4, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// ICadPolyLineOnSurface operations


/////////////////////////////////////////////////////////////////////////////
// ICadPointsOnSurface properties

LPDISPATCH ICadPointsOnSurface::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x1, VT_DISPATCH, (void*)&result);
	return result;
}

void ICadPointsOnSurface::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x1, VT_DISPATCH, propVal);
}

long ICadPointsOnSurface::GetCount()
{
	long result;
	GetProperty(0x2, VT_I4, (void*)&result);
	return result;
}

void ICadPointsOnSurface::SetCount(long propVal)
{
	SetProperty(0x2, VT_I4, propVal);
}

LPDISPATCH ICadPointsOnSurface::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x5, VT_DISPATCH, (void*)&result);
	return result;
}

void ICadPointsOnSurface::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x5, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// ICadPointsOnSurface operations

LPDISPATCH ICadPointsOnSurface::Item(long Num)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Num);
	return result;
}

LPDISPATCH ICadPointsOnSurface::_Item(long Num)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Num);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ICadPointOnSurface properties

LPDISPATCH ICadPointOnSurface::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x1, VT_DISPATCH, (void*)&result);
	return result;
}

void ICadPointOnSurface::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x1, VT_DISPATCH, propVal);
}

double ICadPointOnSurface::GetX()
{
	double result;
	GetProperty(0x2, VT_R8, (void*)&result);
	return result;
}

void ICadPointOnSurface::SetX(double propVal)
{
	SetProperty(0x2, VT_R8, propVal);
}

double ICadPointOnSurface::GetY()
{
	double result;
	GetProperty(0x3, VT_R8, (void*)&result);
	return result;
}

void ICadPointOnSurface::SetY(double propVal)
{
	SetProperty(0x3, VT_R8, propVal);
}

double ICadPointOnSurface::GetZ()
{
	double result;
	GetProperty(0x4, VT_R8, (void*)&result);
	return result;
}

void ICadPointOnSurface::SetZ(double propVal)
{
	SetProperty(0x4, VT_R8, propVal);
}

double ICadPointOnSurface::GetI()
{
	double result;
	GetProperty(0x5, VT_R8, (void*)&result);
	return result;
}

void ICadPointOnSurface::SetI(double propVal)
{
	SetProperty(0x5, VT_R8, propVal);
}

double ICadPointOnSurface::GetJ()
{
	double result;
	GetProperty(0x6, VT_R8, (void*)&result);
	return result;
}

void ICadPointOnSurface::SetJ(double propVal)
{
	SetProperty(0x6, VT_R8, propVal);
}

double ICadPointOnSurface::GetK()
{
	double result;
	GetProperty(0x7, VT_R8, (void*)&result);
	return result;
}

void ICadPointOnSurface::SetK(double propVal)
{
	SetProperty(0x7, VT_R8, propVal);
}

LPDISPATCH ICadPointOnSurface::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x9, VT_DISPATCH, (void*)&result);
	return result;
}

void ICadPointOnSurface::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x9, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// ICadPointOnSurface operations


/////////////////////////////////////////////////////////////////////////////
// ICadHandle properties

long ICadHandle::GetCollection()
{
	long result;
	GetProperty(0x1, VT_I4, (void*)&result);
	return result;
}

void ICadHandle::SetCollection(long propVal)
{
	SetProperty(0x1, VT_I4, propVal);
}

long ICadHandle::GetPartInstanceId()
{
	long result;
	GetProperty(0x2, VT_I4, (void*)&result);
	return result;
}

void ICadHandle::SetPartInstanceId(long propVal)
{
	SetProperty(0x2, VT_I4, propVal);
}

long ICadHandle::GetSubCadId()
{
	long result;
	GetProperty(0x3, VT_I4, (void*)&result);
	return result;
}

void ICadHandle::SetSubCadId(long propVal)
{
	SetProperty(0x3, VT_I4, propVal);
}

long ICadHandle::GetCadSequence()
{
	long result;
	GetProperty(0x4, VT_I4, (void*)&result);
	return result;
}

void ICadHandle::SetCadSequence(long propVal)
{
	SetProperty(0x4, VT_I4, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// ICadHandle operations


/////////////////////////////////////////////////////////////////////////////
// IPartProgramSettings properties

long IPartProgramSettings::GetAutoAdjustPh9()
{
	long result;
	GetProperty(0x1, VT_I4, (void*)&result);
	return result;
}

void IPartProgramSettings::SetAutoAdjustPh9(long propVal)
{
	SetProperty(0x1, VT_I4, propVal);
}

long IPartProgramSettings::GetWarnLoadProbe()
{
	long result;
	GetProperty(0x2, VT_I4, (void*)&result);
	return result;
}

void IPartProgramSettings::SetWarnLoadProbe(long propVal)
{
	SetProperty(0x2, VT_I4, propVal);
}

long IPartProgramSettings::GetAutoLabelPosition()
{
	long result;
	GetProperty(0x3, VT_I4, (void*)&result);
	return result;
}

void IPartProgramSettings::SetAutoLabelPosition(long propVal)
{
	SetProperty(0x3, VT_I4, propVal);
}

long IPartProgramSettings::GetPointOnlyMode()
{
	long result;
	GetProperty(0x4, VT_I4, (void*)&result);
	return result;
}

void IPartProgramSettings::SetPointOnlyMode(long propVal)
{
	SetProperty(0x4, VT_I4, propVal);
}

long IPartProgramSettings::GetResetGlobalsWhenBranching()
{
	long result;
	GetProperty(0x5, VT_I4, (void*)&result);
	return result;
}

void IPartProgramSettings::SetResetGlobalsWhenBranching(long propVal)
{
	SetProperty(0x5, VT_I4, propVal);
}

long IPartProgramSettings::GetMinusTolerancesShowNegative()
{
	long result;
	GetProperty(0x6, VT_I4, (void*)&result);
	return result;
}

void IPartProgramSettings::SetMinusTolerancesShowNegative(long propVal)
{
	SetProperty(0x6, VT_I4, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IPartProgramSettings operations


/////////////////////////////////////////////////////////////////////////////
// IExecutedCommands properties

LPDISPATCH IExecutedCommands::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x1, VT_DISPATCH, (void*)&result);
	return result;
}

void IExecutedCommands::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x1, VT_DISPATCH, propVal);
}

LPDISPATCH IExecutedCommands::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x2, VT_DISPATCH, (void*)&result);
	return result;
}

void IExecutedCommands::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x2, VT_DISPATCH, propVal);
}

long IExecutedCommands::GetCount()
{
	long result;
	GetProperty(0x3, VT_I4, (void*)&result);
	return result;
}

void IExecutedCommands::SetCount(long propVal)
{
	SetProperty(0x3, VT_I4, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IExecutedCommands operations

LPDISPATCH IExecutedCommands::Item(long Num)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Num);
	return result;
}

LPDISPATCH IExecutedCommands::FindByUniqueID(long HiPart, long LoPart)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4 VTS_I4;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		HiPart, LoPart);
	return result;
}

LPDISPATCH IExecutedCommands::_Item(const VARIANT& Identifier)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&Identifier);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IReportWindow properties

LPDISPATCH IReportWindow::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x1, VT_DISPATCH, (void*)&result);
	return result;
}

void IReportWindow::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x1, VT_DISPATCH, propVal);
}

LPDISPATCH IReportWindow::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x2, VT_DISPATCH, (void*)&result);
	return result;
}

void IReportWindow::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x2, VT_DISPATCH, propVal);
}

long IReportWindow::GetVisible()
{
	long result;
	GetProperty(0x3, VT_I4, (void*)&result);
	return result;
}

void IReportWindow::SetVisible(long propVal)
{
	SetProperty(0x3, VT_I4, propVal);
}

LPDISPATCH IReportWindow::GetPages()
{
	LPDISPATCH result;
	GetProperty(0xa, VT_DISPATCH, (void*)&result);
	return result;
}

void IReportWindow::SetPages(LPDISPATCH propVal)
{
	SetProperty(0xa, VT_DISPATCH, propVal);
}

CString IReportWindow::GetCurrentReport()
{
	CString result;
	GetProperty(0xb, VT_BSTR, (void*)&result);
	return result;
}

void IReportWindow::SetCurrentReport(LPCTSTR propVal)
{
	SetProperty(0xb, VT_BSTR, propVal);
}

long IReportWindow::GetCustomReportCount()
{
	long result;
	GetProperty(0xc, VT_I4, (void*)&result);
	return result;
}

void IReportWindow::SetCustomReportCount(long propVal)
{
	SetProperty(0xc, VT_I4, propVal);
}

long IReportWindow::GetLeft()
{
	long result;
	GetProperty(0x12, VT_I4, (void*)&result);
	return result;
}

void IReportWindow::SetLeft(long propVal)
{
	SetProperty(0x12, VT_I4, propVal);
}

long IReportWindow::GetWidth()
{
	long result;
	GetProperty(0x13, VT_I4, (void*)&result);
	return result;
}

void IReportWindow::SetWidth(long propVal)
{
	SetProperty(0x13, VT_I4, propVal);
}

long IReportWindow::GetTop()
{
	long result;
	GetProperty(0x14, VT_I4, (void*)&result);
	return result;
}

void IReportWindow::SetTop(long propVal)
{
	SetProperty(0x14, VT_I4, propVal);
}

long IReportWindow::GetHeight()
{
	long result;
	GetProperty(0x15, VT_I4, (void*)&result);
	return result;
}

void IReportWindow::SetHeight(long propVal)
{
	SetProperty(0x15, VT_I4, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IReportWindow operations

long IReportWindow::LoadReportTemplate(LPCTSTR filename)
{
	long result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x4, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		filename);
	return result;
}

long IReportWindow::SetCurrentAsDefaultReport()
{
	long result;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
	return result;
}

long IReportWindow::PrintReport()
{
	long result;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
	return result;
}

long IReportWindow::RefreshReport()
{
	long result;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
	return result;
}

long IReportWindow::FullReportMode()
{
	long result;
	InvokeHelper(0x8, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
	return result;
}

long IReportWindow::LastExecutionReportMode()
{
	long result;
	InvokeHelper(0x9, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
	return result;
}

CString IReportWindow::GetCustomReportName(long index)
{
	CString result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0xd, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
		index);
	return result;
}

long IReportWindow::LoadCustomReport(const VARIANT& NameOrNumber)
{
	long result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0xe, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		&NameOrNumber);
	return result;
}

long IReportWindow::GenerateStatusReportBitmapUid(LPCTSTR filename, LPCTSTR templatename, long* HiPart, long* LoPart)
{
	long result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR VTS_PI4 VTS_PI4;
	InvokeHelper(0xf, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		filename, templatename, HiPart, LoPart);
	return result;
}

long IReportWindow::GenerateStatusReportBitmapId(LPCTSTR filename, LPCTSTR templatename, LPCTSTR start, LPCTSTR end)
{
	long result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR VTS_BSTR VTS_BSTR;
	InvokeHelper(0x10, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		filename, templatename, start, end);
	return result;
}

long IReportWindow::GenerateStatusReportBitmap(LPCTSTR filename, LPCTSTR templatename, LPDISPATCH startCmd, LPDISPATCH endCmd)
{
	long result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR VTS_DISPATCH VTS_DISPATCH;
	InvokeHelper(0x11, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		filename, templatename, startCmd, endCmd);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IPages properties

LPDISPATCH IPages::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x1, VT_DISPATCH, (void*)&result);
	return result;
}

void IPages::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x1, VT_DISPATCH, propVal);
}

LPDISPATCH IPages::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x2, VT_DISPATCH, (void*)&result);
	return result;
}

void IPages::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x2, VT_DISPATCH, propVal);
}

long IPages::GetCount()
{
	long result;
	GetProperty(0x3, VT_I4, (void*)&result);
	return result;
}

void IPages::SetCount(long propVal)
{
	SetProperty(0x3, VT_I4, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IPages operations

LPDISPATCH IPages::Item(long Num)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Num);
	return result;
}

LPDISPATCH IPages::_Item(long Num)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Num);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IPage properties

long IPage::GetNumber()
{
	long result;
	GetProperty(0x1, VT_I4, (void*)&result);
	return result;
}

void IPage::SetNumber(long propVal)
{
	SetProperty(0x1, VT_I4, propVal);
}

LPDISPATCH IPage::GetReportControls()
{
	LPDISPATCH result;
	GetProperty(0x2, VT_DISPATCH, (void*)&result);
	return result;
}

void IPage::SetReportControls(LPDISPATCH propVal)
{
	SetProperty(0x2, VT_DISPATCH, propVal);
}

LPDISPATCH IPage::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x3, VT_DISPATCH, (void*)&result);
	return result;
}

void IPage::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x3, VT_DISPATCH, propVal);
}

LPDISPATCH IPage::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x4, VT_DISPATCH, (void*)&result);
	return result;
}

void IPage::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x4, VT_DISPATCH, propVal);
}

long IPage::GetHeight()
{
	long result;
	GetProperty(0x5, VT_I4, (void*)&result);
	return result;
}

void IPage::SetHeight(long propVal)
{
	SetProperty(0x5, VT_I4, propVal);
}

long IPage::GetWidth()
{
	long result;
	GetProperty(0x6, VT_I4, (void*)&result);
	return result;
}

void IPage::SetWidth(long propVal)
{
	SetProperty(0x6, VT_I4, propVal);
}

long IPage::GetLandScape()
{
	long result;
	GetProperty(0x7, VT_I4, (void*)&result);
	return result;
}

void IPage::SetLandScape(long propVal)
{
	SetProperty(0x7, VT_I4, propVal);
}

long IPage::GetSection()
{
	long result;
	GetProperty(0x8, VT_I4, (void*)&result);
	return result;
}

void IPage::SetSection(long propVal)
{
	SetProperty(0x8, VT_I4, propVal);
}

long IPage::GetDuplicated()
{
	long result;
	GetProperty(0x9, VT_I4, (void*)&result);
	return result;
}

void IPage::SetDuplicated(long propVal)
{
	SetProperty(0x9, VT_I4, propVal);
}

long IPage::GetCustom()
{
	long result;
	GetProperty(0xa, VT_I4, (void*)&result);
	return result;
}

void IPage::SetCustom(long propVal)
{
	SetProperty(0xa, VT_I4, propVal);
}

long IPage::GetPageNumber()
{
	long result;
	GetProperty(0xb, VT_I4, (void*)&result);
	return result;
}

void IPage::SetPageNumber(long propVal)
{
	SetProperty(0xb, VT_I4, propVal);
}

long IPage::GetLeft()
{
	long result;
	GetProperty(0xc, VT_I4, (void*)&result);
	return result;
}

void IPage::SetLeft(long propVal)
{
	SetProperty(0xc, VT_I4, propVal);
}

long IPage::GetRight()
{
	long result;
	GetProperty(0xd, VT_I4, (void*)&result);
	return result;
}

void IPage::SetRight(long propVal)
{
	SetProperty(0xd, VT_I4, propVal);
}

long IPage::GetTop()
{
	long result;
	GetProperty(0xe, VT_I4, (void*)&result);
	return result;
}

void IPage::SetTop(long propVal)
{
	SetProperty(0xe, VT_I4, propVal);
}

long IPage::GetBottom()
{
	long result;
	GetProperty(0xf, VT_I4, (void*)&result);
	return result;
}

void IPage::SetBottom(long propVal)
{
	SetProperty(0xf, VT_I4, propVal);
}

long IPage::Get_Number()
{
	long result;
	GetProperty(0x0, VT_I4, (void*)&result);
	return result;
}

void IPage::Set_Number(long propVal)
{
	SetProperty(0x0, VT_I4, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IPage operations


/////////////////////////////////////////////////////////////////////////////
// IReportControls properties

LPDISPATCH IReportControls::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x2, VT_DISPATCH, (void*)&result);
	return result;
}

void IReportControls::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x2, VT_DISPATCH, propVal);
}

LPDISPATCH IReportControls::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x3, VT_DISPATCH, (void*)&result);
	return result;
}

void IReportControls::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x3, VT_DISPATCH, propVal);
}

long IReportControls::GetCount()
{
	long result;
	GetProperty(0x4, VT_I4, (void*)&result);
	return result;
}

void IReportControls::SetCount(long propVal)
{
	SetProperty(0x4, VT_I4, propVal);
}

long IReportControls::GetReadOnly()
{
	long result;
	GetProperty(0x8, VT_I4, (void*)&result);
	return result;
}

void IReportControls::SetReadOnly(long propVal)
{
	SetProperty(0x8, VT_I4, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IReportControls operations

LPDISPATCH IReportControls::Item(const VARIANT& NameOrNumber)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x1, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&NameOrNumber);
	return result;
}

LPDISPATCH IReportControls::Add(long ObjectType, long Left, long Top, long Right, long Bottom)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		ObjectType, Left, Top, Right, Bottom);
	return result;
}

long IReportControls::Remove(const VARIANT& NameOrNumber)
{
	long result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		&NameOrNumber);
	return result;
}

LPDISPATCH IReportControls::ItemControl(const VARIANT& NameOrNumber)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x9, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&NameOrNumber);
	return result;
}

LPDISPATCH IReportControls::AddControl(long ObjectType, long Left, long Top, long Right, long Bottom)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4;
	InvokeHelper(0xa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		ObjectType, Left, Top, Right, Bottom);
	return result;
}

void IReportControls::RefreshControls()
{
	InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IReportControls::_Item(const VARIANT& NameOrNumber)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&NameOrNumber);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IReportControl properties

LPDISPATCH IReportControl::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x1, VT_DISPATCH, (void*)&result);
	return result;
}

void IReportControl::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x1, VT_DISPATCH, propVal);
}

LPDISPATCH IReportControl::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x2, VT_DISPATCH, (void*)&result);
	return result;
}

void IReportControl::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x2, VT_DISPATCH, propVal);
}

long IReportControl::GetTop()
{
	long result;
	GetProperty(0x3, VT_I4, (void*)&result);
	return result;
}

void IReportControl::SetTop(long propVal)
{
	SetProperty(0x3, VT_I4, propVal);
}

long IReportControl::GetBottom()
{
	long result;
	GetProperty(0x4, VT_I4, (void*)&result);
	return result;
}

void IReportControl::SetBottom(long propVal)
{
	SetProperty(0x4, VT_I4, propVal);
}

long IReportControl::GetLeft()
{
	long result;
	GetProperty(0x5, VT_I4, (void*)&result);
	return result;
}

void IReportControl::SetLeft(long propVal)
{
	SetProperty(0x5, VT_I4, propVal);
}

long IReportControl::GetRight()
{
	long result;
	GetProperty(0x6, VT_I4, (void*)&result);
	return result;
}

void IReportControl::SetRight(long propVal)
{
	SetProperty(0x6, VT_I4, propVal);
}

CString IReportControl::GetId()
{
	CString result;
	GetProperty(0x7, VT_BSTR, (void*)&result);
	return result;
}

void IReportControl::SetId(LPCTSTR propVal)
{
	SetProperty(0x7, VT_BSTR, propVal);
}

long IReportControl::GetSelected()
{
	long result;
	GetProperty(0x8, VT_I4, (void*)&result);
	return result;
}

void IReportControl::SetSelected(long propVal)
{
	SetProperty(0x8, VT_I4, propVal);
}

long IReportControl::GetVisible()
{
	long result;
	GetProperty(0x9, VT_I4, (void*)&result);
	return result;
}

void IReportControl::SetVisible(long propVal)
{
	SetProperty(0x9, VT_I4, propVal);
}

long IReportControl::GetHeight()
{
	long result;
	GetProperty(0xa, VT_I4, (void*)&result);
	return result;
}

void IReportControl::SetHeight(long propVal)
{
	SetProperty(0xa, VT_I4, propVal);
}

long IReportControl::GetWidth()
{
	long result;
	GetProperty(0xb, VT_I4, (void*)&result);
	return result;
}

void IReportControl::SetWidth(long propVal)
{
	SetProperty(0xb, VT_I4, propVal);
}

long IReportControl::GetType()
{
	long result;
	GetProperty(0xc, VT_I4, (void*)&result);
	return result;
}

void IReportControl::SetType(long propVal)
{
	SetProperty(0xc, VT_I4, propVal);
}

LPDISPATCH IReportControl::GetCommand()
{
	LPDISPATCH result;
	GetProperty(0xd, VT_DISPATCH, (void*)&result);
	return result;
}

void IReportControl::SetCommand(LPDISPATCH propVal)
{
	SetProperty(0xd, VT_DISPATCH, propVal);
}

CString IReportControl::GetLabelTemplateName()
{
	CString result;
	GetProperty(0xe, VT_BSTR, (void*)&result);
	return result;
}

void IReportControl::SetLabelTemplateName(LPCTSTR propVal)
{
	SetProperty(0xe, VT_BSTR, propVal);
}

CString IReportControl::GetCADReferenceName()
{
	CString result;
	GetProperty(0xf, VT_BSTR, (void*)&result);
	return result;
}

void IReportControl::SetCADReferenceName(LPCTSTR propVal)
{
	SetProperty(0xf, VT_BSTR, propVal);
}

long IReportControl::GetLeaderLineVisible()
{
	long result;
	GetProperty(0x10, VT_I4, (void*)&result);
	return result;
}

void IReportControl::SetLeaderLineVisible(long propVal)
{
	SetProperty(0x10, VT_I4, propVal);
}

long IReportControl::GetIsAnalysisWindow()
{
	long result;
	GetProperty(0x11, VT_I4, (void*)&result);
	return result;
}

void IReportControl::SetIsAnalysisWindow(long propVal)
{
	SetProperty(0x11, VT_I4, propVal);
}

long IReportControl::GetIsLabel()
{
	long result;
	GetProperty(0x12, VT_I4, (void*)&result);
	return result;
}

void IReportControl::SetIsLabel(long propVal)
{
	SetProperty(0x12, VT_I4, propVal);
}

long IReportControl::GetIsLeaderLine()
{
	long result;
	GetProperty(0x13, VT_I4, (void*)&result);
	return result;
}

void IReportControl::SetIsLeaderLine(long propVal)
{
	SetProperty(0x13, VT_I4, propVal);
}

LPDISPATCH IReportControl::GetAnalysisWindow()
{
	LPDISPATCH result;
	GetProperty(0x14, VT_DISPATCH, (void*)&result);
	return result;
}

void IReportControl::SetAnalysisWindow(LPDISPATCH propVal)
{
	SetProperty(0x14, VT_DISPATCH, propVal);
}

LPDISPATCH IReportControl::GetOffset()
{
	LPDISPATCH result;
	GetProperty(0x15, VT_DISPATCH, (void*)&result);
	return result;
}

void IReportControl::SetOffset(LPDISPATCH propVal)
{
	SetProperty(0x15, VT_DISPATCH, propVal);
}

double IReportControl::GetScaleFactor()
{
	double result;
	GetProperty(0x16, VT_R8, (void*)&result);
	return result;
}

void IReportControl::SetScaleFactor(double propVal)
{
	SetProperty(0x16, VT_R8, propVal);
}

LPDISPATCH IReportControl::GetRotation()
{
	LPDISPATCH result;
	GetProperty(0x17, VT_DISPATCH, (void*)&result);
	return result;
}

void IReportControl::SetRotation(LPDISPATCH propVal)
{
	SetProperty(0x17, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IReportControl operations

long IReportControl::FlipCROView(long _isVertical)
{
	long result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x18, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		_isVertical);
	return result;
}

long IReportControl::FlipCROViewByAxis(long _axisToUse)
{
	long result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x19, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		_axisToUse);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IQuickStart properties

LPDISPATCH IQuickStart::GetCurrentTask()
{
	LPDISPATCH result;
	GetProperty(0x1, VT_DISPATCH, (void*)&result);
	return result;
}

void IQuickStart::SetCurrentTask(LPDISPATCH propVal)
{
	SetProperty(0x1, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IQuickStart operations

LPDISPATCH IQuickStart::BeginTask(long TaskNum)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x2, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		TaskNum);
	return result;
}

BOOL IQuickStart::RemoveHit()
{
	BOOL result;
	InvokeHelper(0x3, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IQuickStartTask properties

LPDISPATCH IQuickStartTask::GetSteps()
{
	LPDISPATCH result;
	GetProperty(0x1, VT_DISPATCH, (void*)&result);
	return result;
}

void IQuickStartTask::SetSteps(LPDISPATCH propVal)
{
	SetProperty(0x1, VT_DISPATCH, propVal);
}

long IQuickStartTask::GetNumSteps()
{
	long result;
	GetProperty(0x2, VT_I4, (void*)&result);
	return result;
}

void IQuickStartTask::SetNumSteps(long propVal)
{
	SetProperty(0x2, VT_I4, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IQuickStartTask operations

LPDISPATCH IQuickStartTask::NextStep()
{
	LPDISPATCH result;
	InvokeHelper(0x3, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH IQuickStartTask::PrevStep()
{
	LPDISPATCH result;
	InvokeHelper(0x4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH IQuickStartTask::Finish()
{
	LPDISPATCH result;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IQuickStartSteps properties

long IQuickStartSteps::GetCount()
{
	long result;
	GetProperty(0x1, VT_I4, (void*)&result);
	return result;
}

void IQuickStartSteps::SetCount(long propVal)
{
	SetProperty(0x1, VT_I4, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IQuickStartSteps operations

LPDISPATCH IQuickStartSteps::Item(long Num)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x3, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Num);
	return result;
}

LPDISPATCH IQuickStartSteps::_Item(long Num)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Num);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IQuickStartStep properties

BOOL IQuickStartStep::GetExpectsHits()
{
	BOOL result;
	GetProperty(0x1, VT_BOOL, (void*)&result);
	return result;
}

void IQuickStartStep::SetExpectsHits(BOOL propVal)
{
	SetProperty(0x1, VT_BOOL, propVal);
}

BOOL IQuickStartStep::GetExpectsUserInput()
{
	BOOL result;
	GetProperty(0x2, VT_BOOL, (void*)&result);
	return result;
}

void IQuickStartStep::SetExpectsUserInput(BOOL propVal)
{
	SetProperty(0x2, VT_BOOL, propVal);
}

long IQuickStartStep::GetNumHits()
{
	long result;
	GetProperty(0x3, VT_I4, (void*)&result);
	return result;
}

void IQuickStartStep::SetNumHits(long propVal)
{
	SetProperty(0x3, VT_I4, propVal);
}

CString IQuickStartStep::GetStepHint()
{
	CString result;
	GetProperty(0x4, VT_BSTR, (void*)&result);
	return result;
}

void IQuickStartStep::SetStepHint(LPCTSTR propVal)
{
	SetProperty(0x4, VT_BSTR, propVal);
}

BOOL IQuickStartStep::GetCanBeCompleted()
{
	BOOL result;
	GetProperty(0x5, VT_BOOL, (void*)&result);
	return result;
}

void IQuickStartStep::SetCanBeCompleted(BOOL propVal)
{
	SetProperty(0x5, VT_BOOL, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IQuickStartStep operations

CString IQuickStartStep::GetPrompt(long Num)
{
	CString result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
		Num);
	return result;
}

CString IQuickStartStep::GetEditText(long Num)
{
	CString result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
		Num);
	return result;
}

void IQuickStartStep::SetEditText(long Num, LPCTSTR Value)
{
	static BYTE parms[] =
		VTS_I4 VTS_BSTR;
	InvokeHelper(0x8, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Num, Value);
}

CString IQuickStartStep::GetControlText(long Num)
{
	CString result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x9, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
		Num);
	return result;
}

BOOL IQuickStartStep::GetControlState(long Num)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0xa, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		Num);
	return result;
}

void IQuickStartStep::SetControlState(long Num, BOOL Value)
{
	static BYTE parms[] =
		VTS_I4 VTS_BOOL;
	InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Num, Value);
}

CString IQuickStartStep::GetSelectionPrompt()
{
	CString result;
	InvokeHelper(0xc, DISPATCH_METHOD, VT_BSTR, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IQuickStartAddedCommands properties

long IQuickStartAddedCommands::GetCount()
{
	long result;
	GetProperty(0x1, VT_I4, (void*)&result);
	return result;
}

void IQuickStartAddedCommands::SetCount(long propVal)
{
	SetProperty(0x1, VT_I4, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IQuickStartAddedCommands operations

LPDISPATCH IQuickStartAddedCommands::Item(long Num)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x3, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Num);
	return result;
}

LPDISPATCH IQuickStartAddedCommands::_Item(long Num)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Num);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IBundledStations properties

long IBundledStations::GetCount()
{
	long result;
	GetProperty(0x1, VT_I4, (void*)&result);
	return result;
}

void IBundledStations::SetCount(long propVal)
{
	SetProperty(0x1, VT_I4, propVal);
}

LPDISPATCH IBundledStations::GetActiveStation()
{
	LPDISPATCH result;
	GetProperty(0x2, VT_DISPATCH, (void*)&result);
	return result;
}

void IBundledStations::SetActiveStation(LPDISPATCH propVal)
{
	SetProperty(0x2, VT_DISPATCH, propVal);
}

LPDISPATCH IBundledStations::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x3, VT_DISPATCH, (void*)&result);
	return result;
}

void IBundledStations::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x3, VT_DISPATCH, propVal);
}

LPDISPATCH IBundledStations::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x4, VT_DISPATCH, (void*)&result);
	return result;
}

void IBundledStations::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x4, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IBundledStations operations

LPDISPATCH IBundledStations::Add()
{
	LPDISPATCH result;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

BOOL IBundledStations::Remove(const VARIANT& StringOrNumber)
{
	BOOL result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		&StringOrNumber);
	return result;
}

LPDISPATCH IBundledStations::Item(const VARIANT& StringOrNumber)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x8, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&StringOrNumber);
	return result;
}

LPDISPATCH IBundledStations::_Item(const VARIANT& StringOrNumber)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&StringOrNumber);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IBundledStation properties

CString IBundledStation::GetId()
{
	CString result;
	GetProperty(0x1, VT_BSTR, (void*)&result);
	return result;
}

void IBundledStation::SetId(LPCTSTR propVal)
{
	SetProperty(0x1, VT_BSTR, propVal);
}

long IBundledStation::GetIndexID()
{
	long result;
	GetProperty(0x2, VT_I4, (void*)&result);
	return result;
}

void IBundledStation::SetIndexID(long propVal)
{
	SetProperty(0x2, VT_I4, propVal);
}

BOOL IBundledStation::GetOriented()
{
	BOOL result;
	GetProperty(0x3, VT_BOOL, (void*)&result);
	return result;
}

void IBundledStation::SetOriented(BOOL propVal)
{
	SetProperty(0x3, VT_BOOL, propVal);
}

BOOL IBundledStation::GetLocked()
{
	BOOL result;
	GetProperty(0x4, VT_BOOL, (void*)&result);
	return result;
}

void IBundledStation::SetLocked(BOOL propVal)
{
	SetProperty(0x4, VT_BOOL, propVal);
}

BOOL IBundledStation::GetIsActive()
{
	BOOL result;
	GetProperty(0x5, VT_BOOL, (void*)&result);
	return result;
}

void IBundledStation::SetIsActive(BOOL propVal)
{
	SetProperty(0x5, VT_BOOL, propVal);
}

LPDISPATCH IBundledStation::GetMatrix()
{
	LPDISPATCH result;
	GetProperty(0x6, VT_DISPATCH, (void*)&result);
	return result;
}

void IBundledStation::SetMatrix(LPDISPATCH propVal)
{
	SetProperty(0x6, VT_DISPATCH, propVal);
}

LPDISPATCH IBundledStation::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x7, VT_DISPATCH, (void*)&result);
	return result;
}

void IBundledStation::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x7, VT_DISPATCH, propVal);
}

LPDISPATCH IBundledStation::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x8, VT_DISPATCH, (void*)&result);
	return result;
}

void IBundledStation::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x8, VT_DISPATCH, propVal);
}

CString IBundledStation::Get_id()
{
	CString result;
	GetProperty(0x0, VT_BSTR, (void*)&result);
	return result;
}

void IBundledStation::Set_id(LPCTSTR propVal)
{
	SetProperty(0x0, VT_BSTR, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IBundledStation operations

BOOL IBundledStation::SetActive()
{
	BOOL result;
	InvokeHelper(0x9, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ISection properties

CString ISection::GetName()
{
	CString result;
	GetProperty(0x1, VT_BSTR, (void*)&result);
	return result;
}

void ISection::SetName(LPCTSTR propVal)
{
	SetProperty(0x1, VT_BSTR, propVal);
}

long ISection::GetNumber()
{
	long result;
	GetProperty(0x2, VT_I4, (void*)&result);
	return result;
}

void ISection::SetNumber(long propVal)
{
	SetProperty(0x2, VT_I4, propVal);
}

LPDISPATCH ISection::GetReportControls()
{
	LPDISPATCH result;
	GetProperty(0x3, VT_DISPATCH, (void*)&result);
	return result;
}

void ISection::SetReportControls(LPDISPATCH propVal)
{
	SetProperty(0x3, VT_DISPATCH, propVal);
}

LPDISPATCH ISection::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x4, VT_DISPATCH, (void*)&result);
	return result;
}

void ISection::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x4, VT_DISPATCH, propVal);
}

LPDISPATCH ISection::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x5, VT_DISPATCH, (void*)&result);
	return result;
}

void ISection::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x5, VT_DISPATCH, propVal);
}

long ISection::GetHeight()
{
	long result;
	GetProperty(0x6, VT_I4, (void*)&result);
	return result;
}

void ISection::SetHeight(long propVal)
{
	SetProperty(0x6, VT_I4, propVal);
}

long ISection::GetWidth()
{
	long result;
	GetProperty(0x7, VT_I4, (void*)&result);
	return result;
}

void ISection::SetWidth(long propVal)
{
	SetProperty(0x7, VT_I4, propVal);
}

CString ISection::Get_Name()
{
	CString result;
	GetProperty(0x0, VT_BSTR, (void*)&result);
	return result;
}

void ISection::Set_Name(LPCTSTR propVal)
{
	SetProperty(0x0, VT_BSTR, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// ISection operations


/////////////////////////////////////////////////////////////////////////////
// ISections properties

long ISections::GetCount()
{
	long result;
	GetProperty(0x5, VT_I4, (void*)&result);
	return result;
}

void ISections::SetCount(long propVal)
{
	SetProperty(0x5, VT_I4, propVal);
}

LPDISPATCH ISections::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x6, VT_DISPATCH, (void*)&result);
	return result;
}

void ISections::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x6, VT_DISPATCH, propVal);
}

LPDISPATCH ISections::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x7, VT_DISPATCH, (void*)&result);
	return result;
}

void ISections::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x7, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// ISections operations

LPDISPATCH ISections::Add(LPCTSTR Name)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x1, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Name);
	return result;
}

BOOL ISections::Remove(const VARIANT& NameOrNumber)
{
	BOOL result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x2, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		&NameOrNumber);
	return result;
}

LPDISPATCH ISections::Item(const VARIANT& NameOrNumber)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x3, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&NameOrNumber);
	return result;
}

LPDISPATCH ISections::InsertSectionBefore(LPCTSTR Name)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Name);
	return result;
}

LPDISPATCH ISections::_Item(const VARIANT& NameOrNumber)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&NameOrNumber);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IReportTemplate properties

BOOL IReportTemplate::GetVisible()
{
	BOOL result;
	GetProperty(0x1, VT_BOOL, (void*)&result);
	return result;
}

void IReportTemplate::SetVisible(BOOL propVal)
{
	SetProperty(0x1, VT_BOOL, propVal);
}

LPDISPATCH IReportTemplate::GetSections()
{
	LPDISPATCH result;
	GetProperty(0x2, VT_DISPATCH, (void*)&result);
	return result;
}

void IReportTemplate::SetSections(LPDISPATCH propVal)
{
	SetProperty(0x2, VT_DISPATCH, propVal);
}

LPDISPATCH IReportTemplate::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x3, VT_DISPATCH, (void*)&result);
	return result;
}

void IReportTemplate::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x3, VT_DISPATCH, propVal);
}

LPDISPATCH IReportTemplate::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x4, VT_DISPATCH, (void*)&result);
	return result;
}

void IReportTemplate::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x4, VT_DISPATCH, propVal);
}

CString IReportTemplate::GetName()
{
	CString result;
	GetProperty(0x5, VT_BSTR, (void*)&result);
	return result;
}

void IReportTemplate::SetName(LPCTSTR propVal)
{
	SetProperty(0x5, VT_BSTR, propVal);
}

CString IReportTemplate::GetFullName()
{
	CString result;
	GetProperty(0x6, VT_BSTR, (void*)&result);
	return result;
}

void IReportTemplate::SetFullName(LPCTSTR propVal)
{
	SetProperty(0x6, VT_BSTR, propVal);
}

LPDISPATCH IReportTemplate::GetColors()
{
	LPDISPATCH result;
	GetProperty(0xa, VT_DISPATCH, (void*)&result);
	return result;
}

void IReportTemplate::SetColors(LPDISPATCH propVal)
{
	SetProperty(0xa, VT_DISPATCH, propVal);
}

CString IReportTemplate::GetLearnTimeProgram()
{
	CString result;
	GetProperty(0xb, VT_BSTR, (void*)&result);
	return result;
}

void IReportTemplate::SetLearnTimeProgram(LPCTSTR propVal)
{
	SetProperty(0xb, VT_BSTR, propVal);
}

CString IReportTemplate::GetRunTimeProgram()
{
	CString result;
	GetProperty(0xc, VT_BSTR, (void*)&result);
	return result;
}

void IReportTemplate::SetRunTimeProgram(LPCTSTR propVal)
{
	SetProperty(0xc, VT_BSTR, propVal);
}

long IReportTemplate::GetPageOrientation()
{
	long result;
	GetProperty(0xd, VT_I4, (void*)&result);
	return result;
}

void IReportTemplate::SetPageOrientation(long propVal)
{
	SetProperty(0xd, VT_I4, propVal);
}

long IReportTemplate::GetPageSize()
{
	long result;
	GetProperty(0xe, VT_I4, (void*)&result);
	return result;
}

void IReportTemplate::SetPageSize(long propVal)
{
	SetProperty(0xe, VT_I4, propVal);
}

CString IReportTemplate::Get_Name()
{
	CString result;
	GetProperty(0x0, VT_BSTR, (void*)&result);
	return result;
}

void IReportTemplate::Set_Name(LPCTSTR propVal)
{
	SetProperty(0x0, VT_BSTR, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IReportTemplate operations

BOOL IReportTemplate::Save()
{
	BOOL result;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
	return result;
}

BOOL IReportTemplate::SaveAs(LPCTSTR filename)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x8, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		filename);
	return result;
}

void IReportTemplate::Close()
{
	InvokeHelper(0x9, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// IReportTemplates properties

LPDISPATCH IReportTemplates::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x1, VT_DISPATCH, (void*)&result);
	return result;
}

void IReportTemplates::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x1, VT_DISPATCH, propVal);
}

LPDISPATCH IReportTemplates::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x2, VT_DISPATCH, (void*)&result);
	return result;
}

void IReportTemplates::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x2, VT_DISPATCH, propVal);
}

long IReportTemplates::GetCount()
{
	long result;
	GetProperty(0x3, VT_I4, (void*)&result);
	return result;
}

void IReportTemplates::SetCount(long propVal)
{
	SetProperty(0x3, VT_I4, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IReportTemplates operations

LPDISPATCH IReportTemplates::Open(LPCTSTR filename)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		filename);
	return result;
}

LPDISPATCH IReportTemplates::Add()
{
	LPDISPATCH result;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH IReportTemplates::Item(const VARIANT& NameOrNumber)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&NameOrNumber);
	return result;
}

LPDISPATCH IReportTemplates::_Item(const VARIANT& NameOrNumber)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&NameOrNumber);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IColors properties

LPDISPATCH IColors::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x1, VT_DISPATCH, (void*)&result);
	return result;
}

void IColors::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x1, VT_DISPATCH, propVal);
}

LPDISPATCH IColors::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x2, VT_DISPATCH, (void*)&result);
	return result;
}

void IColors::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x2, VT_DISPATCH, propVal);
}

long IColors::GetModified()
{
	long result;
	GetProperty(0x3, VT_I4, (void*)&result);
	return result;
}

void IColors::SetModified(long propVal)
{
	SetProperty(0x3, VT_I4, propVal);
}

long IColors::GetBackground()
{
	long result;
	GetProperty(0x4, VT_I4, (void*)&result);
	return result;
}

void IColors::SetBackground(long propVal)
{
	SetProperty(0x4, VT_I4, propVal);
}

long IColors::GetDimensionBackground()
{
	long result;
	GetProperty(0x5, VT_I4, (void*)&result);
	return result;
}

void IColors::SetDimensionBackground(long propVal)
{
	SetProperty(0x5, VT_I4, propVal);
}

long IColors::GetHighLightBackground()
{
	long result;
	GetProperty(0x6, VT_I4, (void*)&result);
	return result;
}

void IColors::SetHighLightBackground(long propVal)
{
	SetProperty(0x6, VT_I4, propVal);
}

long IColors::GetNumTableColors()
{
	long result;
	GetProperty(0x7, VT_I4, (void*)&result);
	return result;
}

void IColors::SetNumTableColors(long propVal)
{
	SetProperty(0x7, VT_I4, propVal);
}

long IColors::GetCount()
{
	long result;
	GetProperty(0x8, VT_I4, (void*)&result);
	return result;
}

void IColors::SetCount(long propVal)
{
	SetProperty(0x8, VT_I4, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IColors operations

void IColors::SaveChanges()
{
	InvokeHelper(0xd, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IColors::DiscardChanges()
{
	InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IColors::BuildColortable()
{
	InvokeHelper(0xf, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

long IColors::GetColorTableColor(long colorIndex)
{
	long result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x10, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		colorIndex);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IColor properties

long IColor::Get_Standard()
{
	long result;
	GetProperty(0x0, VT_I4, (void*)&result);
	return result;
}

void IColor::Set_Standard(long propVal)
{
	SetProperty(0x0, VT_I4, propVal);
}

LPDISPATCH IColor::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x1, VT_DISPATCH, (void*)&result);
	return result;
}

void IColor::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x1, VT_DISPATCH, propVal);
}

LPDISPATCH IColor::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x2, VT_DISPATCH, (void*)&result);
	return result;
}

void IColor::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x2, VT_DISPATCH, propVal);
}

long IColor::GetColorParentType()
{
	long result;
	GetProperty(0x3, VT_I4, (void*)&result);
	return result;
}

void IColor::SetColorParentType(long propVal)
{
	SetProperty(0x3, VT_I4, propVal);
}

long IColor::GetStandard()
{
	long result;
	GetProperty(0x4, VT_I4, (void*)&result);
	return result;
}

void IColor::SetStandard(long propVal)
{
	SetProperty(0x4, VT_I4, propVal);
}

long IColor::GetMarked()
{
	long result;
	GetProperty(0x5, VT_I4, (void*)&result);
	return result;
}

void IColor::SetMarked(long propVal)
{
	SetProperty(0x5, VT_I4, propVal);
}

long IColor::GetDebug()
{
	long result;
	GetProperty(0x6, VT_I4, (void*)&result);
	return result;
}

void IColor::SetDebug(long propVal)
{
	SetProperty(0x6, VT_I4, propVal);
}

long IColor::GetOutTol()
{
	long result;
	GetProperty(0x7, VT_I4, (void*)&result);
	return result;
}

void IColor::SetOutTol(long propVal)
{
	SetProperty(0x7, VT_I4, propVal);
}

long IColor::GetStandardBackground()
{
	long result;
	GetProperty(0x8, VT_I4, (void*)&result);
	return result;
}

void IColor::SetStandardBackground(long propVal)
{
	SetProperty(0x8, VT_I4, propVal);
}

long IColor::GetMarkedBackground()
{
	long result;
	GetProperty(0x9, VT_I4, (void*)&result);
	return result;
}

void IColor::SetMarkedBackground(long propVal)
{
	SetProperty(0x9, VT_I4, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IColor operations

void IColor::Remove()
{
	InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IColor::SaveChanges()
{
	InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IColor::DiscardChanges()
{
	InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// IExecutionWindow properties

LPDISPATCH IExecutionWindow::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x1, VT_DISPATCH, (void*)&result);
	return result;
}

void IExecutionWindow::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x1, VT_DISPATCH, propVal);
}

BOOL IExecutionWindow::GetVisible()
{
	BOOL result;
	GetProperty(0x2, VT_BOOL, (void*)&result);
	return result;
}

void IExecutionWindow::SetVisible(BOOL propVal)
{
	SetProperty(0x2, VT_BOOL, propVal);
}

BOOL IExecutionWindow::GetAvailable()
{
	BOOL result;
	GetProperty(0x3, VT_BOOL, (void*)&result);
	return result;
}

void IExecutionWindow::SetAvailable(BOOL propVal)
{
	SetProperty(0x3, VT_BOOL, propVal);
}

long IExecutionWindow::GetLeft()
{
	long result;
	GetProperty(0x4, VT_I4, (void*)&result);
	return result;
}

void IExecutionWindow::SetLeft(long propVal)
{
	SetProperty(0x4, VT_I4, propVal);
}

long IExecutionWindow::GetWidth()
{
	long result;
	GetProperty(0x5, VT_I4, (void*)&result);
	return result;
}

void IExecutionWindow::SetWidth(long propVal)
{
	SetProperty(0x5, VT_I4, propVal);
}

long IExecutionWindow::GetTop()
{
	long result;
	GetProperty(0x6, VT_I4, (void*)&result);
	return result;
}

void IExecutionWindow::SetTop(long propVal)
{
	SetProperty(0x6, VT_I4, propVal);
}

long IExecutionWindow::GetHeight()
{
	long result;
	GetProperty(0x7, VT_I4, (void*)&result);
	return result;
}

void IExecutionWindow::SetHeight(long propVal)
{
	SetProperty(0x7, VT_I4, propVal);
}

LPDISPATCH IExecutionWindow::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x8, VT_DISPATCH, (void*)&result);
	return result;
}

void IExecutionWindow::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x8, VT_DISPATCH, propVal);
}

long IExecutionWindow::GetArmNumber()
{
	long result;
	GetProperty(0x15, VT_I4, (void*)&result);
	return result;
}

void IExecutionWindow::SetArmNumber(long propVal)
{
	SetProperty(0x15, VT_I4, propVal);
}

BOOL IExecutionWindow::Get_Visible()
{
	BOOL result;
	GetProperty(0x0, VT_BOOL, (void*)&result);
	return result;
}

void IExecutionWindow::Set_Visible(BOOL propVal)
{
	SetProperty(0x0, VT_BOOL, propVal);
}

BOOL IExecutionWindow::GetShowStopButton()
{
	BOOL result;
	GetProperty(0x16, VT_BOOL, (void*)&result);
	return result;
}

void IExecutionWindow::SetShowStopButton(BOOL propVal)
{
	SetProperty(0x16, VT_BOOL, propVal);
}

BOOL IExecutionWindow::GetShowSkipButton()
{
	BOOL result;
	GetProperty(0x17, VT_BOOL, (void*)&result);
	return result;
}

void IExecutionWindow::SetShowSkipButton(BOOL propVal)
{
	SetProperty(0x17, VT_BOOL, propVal);
}

BOOL IExecutionWindow::GetShowContinueButton()
{
	BOOL result;
	GetProperty(0x18, VT_BOOL, (void*)&result);
	return result;
}

void IExecutionWindow::SetShowContinueButton(BOOL propVal)
{
	SetProperty(0x18, VT_BOOL, propVal);
}

BOOL IExecutionWindow::GetShowJumpButton()
{
	BOOL result;
	GetProperty(0x19, VT_BOOL, (void*)&result);
	return result;
}

void IExecutionWindow::SetShowJumpButton(BOOL propVal)
{
	SetProperty(0x19, VT_BOOL, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IExecutionWindow operations

void IExecutionWindow::CancelExecution()
{
	InvokeHelper(0x9, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IExecutionWindow::EraseHit()
{
	InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IExecutionWindow::Continue()
{
	InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IExecutionWindow::stop()
{
	InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IExecutionWindow::Skip()
{
	InvokeHelper(0xd, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IExecutionWindow::Jump()
{
	InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IExecutionWindow::StepNext()
{
	InvokeHelper(0xf, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IExecutionWindow::StepInto()
{
	InvokeHelper(0x10, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IExecutionWindow::NewRow()
{
	InvokeHelper(0x11, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IExecutionWindow::ScanDone()
{
	InvokeHelper(0x12, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IExecutionWindow::Watch()
{
	InvokeHelper(0x13, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IExecutionWindow::ScaleProbe()
{
	InvokeHelper(0x14, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// IReadoutWindow properties

LPDISPATCH IReadoutWindow::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x1, VT_DISPATCH, (void*)&result);
	return result;
}

void IReadoutWindow::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x1, VT_DISPATCH, propVal);
}

BOOL IReadoutWindow::GetVisible()
{
	BOOL result;
	GetProperty(0x2, VT_BOOL, (void*)&result);
	return result;
}

void IReadoutWindow::SetVisible(BOOL propVal)
{
	SetProperty(0x2, VT_BOOL, propVal);
}

long IReadoutWindow::GetLeft()
{
	long result;
	GetProperty(0x3, VT_I4, (void*)&result);
	return result;
}

void IReadoutWindow::SetLeft(long propVal)
{
	SetProperty(0x3, VT_I4, propVal);
}

long IReadoutWindow::GetWidth()
{
	long result;
	GetProperty(0x4, VT_I4, (void*)&result);
	return result;
}

void IReadoutWindow::SetWidth(long propVal)
{
	SetProperty(0x4, VT_I4, propVal);
}

long IReadoutWindow::GetTop()
{
	long result;
	GetProperty(0x5, VT_I4, (void*)&result);
	return result;
}

void IReadoutWindow::SetTop(long propVal)
{
	SetProperty(0x5, VT_I4, propVal);
}

long IReadoutWindow::GetHeight()
{
	long result;
	GetProperty(0x6, VT_I4, (void*)&result);
	return result;
}

void IReadoutWindow::SetHeight(long propVal)
{
	SetProperty(0x6, VT_I4, propVal);
}

BOOL IReadoutWindow::GetMinimized()
{
	BOOL result;
	GetProperty(0x7, VT_BOOL, (void*)&result);
	return result;
}

void IReadoutWindow::SetMinimized(BOOL propVal)
{
	SetProperty(0x7, VT_BOOL, propVal);
}

BOOL IReadoutWindow::GetMaximized()
{
	BOOL result;
	GetProperty(0x8, VT_BOOL, (void*)&result);
	return result;
}

void IReadoutWindow::SetMaximized(BOOL propVal)
{
	SetProperty(0x8, VT_BOOL, propVal);
}

BOOL IReadoutWindow::GetShowFeatureID()
{
	BOOL result;
	GetProperty(0x9, VT_BOOL, (void*)&result);
	return result;
}

void IReadoutWindow::SetShowFeatureID(BOOL propVal)
{
	SetProperty(0x9, VT_BOOL, propVal);
}

BOOL IReadoutWindow::GetShowFeatureType()
{
	BOOL result;
	GetProperty(0xa, VT_BOOL, (void*)&result);
	return result;
}

void IReadoutWindow::SetShowFeatureType(BOOL propVal)
{
	SetProperty(0xa, VT_BOOL, propVal);
}

BOOL IReadoutWindow::GetShowProbePosition()
{
	BOOL result;
	GetProperty(0xb, VT_BOOL, (void*)&result);
	return result;
}

void IReadoutWindow::SetShowProbePosition(BOOL propVal)
{
	SetProperty(0xb, VT_BOOL, propVal);
}

BOOL IReadoutWindow::GetShowLastHit()
{
	BOOL result;
	GetProperty(0xc, VT_BOOL, (void*)&result);
	return result;
}

void IReadoutWindow::SetShowLastHit(BOOL propVal)
{
	SetProperty(0xc, VT_BOOL, propVal);
}

BOOL IReadoutWindow::GetShowErrorLastMeasuredFeature()
{
	BOOL result;
	GetProperty(0xd, VT_BOOL, (void*)&result);
	return result;
}

void IReadoutWindow::SetShowErrorLastMeasuredFeature(BOOL propVal)
{
	SetProperty(0xd, VT_BOOL, propVal);
}

BOOL IReadoutWindow::GetShowCurrentProbePositionOnScreen()
{
	BOOL result;
	GetProperty(0xe, VT_BOOL, (void*)&result);
	return result;
}

void IReadoutWindow::SetShowCurrentProbePositionOnScreen(BOOL propVal)
{
	SetProperty(0xe, VT_BOOL, propVal);
}

BOOL IReadoutWindow::GetShowDeviationArrowOnScreen()
{
	BOOL result;
	GetProperty(0xf, VT_BOOL, (void*)&result);
	return result;
}

void IReadoutWindow::SetShowDeviationArrowOnScreen(BOOL propVal)
{
	SetProperty(0xf, VT_BOOL, propVal);
}

BOOL IReadoutWindow::GetCenterProbeOnGraphicsWindow()
{
	BOOL result;
	GetProperty(0x10, VT_BOOL, (void*)&result);
	return result;
}

void IReadoutWindow::SetCenterProbeOnGraphicsWindow(BOOL propVal)
{
	SetProperty(0x10, VT_BOOL, propVal);
}

BOOL IReadoutWindow::GetDisplayXAxis()
{
	BOOL result;
	GetProperty(0x11, VT_BOOL, (void*)&result);
	return result;
}

void IReadoutWindow::SetDisplayXAxis(BOOL propVal)
{
	SetProperty(0x11, VT_BOOL, propVal);
}

BOOL IReadoutWindow::GetDisplayYAxis()
{
	BOOL result;
	GetProperty(0x12, VT_BOOL, (void*)&result);
	return result;
}

void IReadoutWindow::SetDisplayYAxis(BOOL propVal)
{
	SetProperty(0x12, VT_BOOL, propVal);
}

BOOL IReadoutWindow::GetDisplayZAxis()
{
	BOOL result;
	GetProperty(0x13, VT_BOOL, (void*)&result);
	return result;
}

void IReadoutWindow::SetDisplayZAxis(BOOL propVal)
{
	SetProperty(0x13, VT_BOOL, propVal);
}

BOOL IReadoutWindow::GetUseMachineCoordinateSystem()
{
	BOOL result;
	GetProperty(0x14, VT_BOOL, (void*)&result);
	return result;
}

void IReadoutWindow::SetUseMachineCoordinateSystem(BOOL propVal)
{
	SetProperty(0x14, VT_BOOL, propVal);
}

BOOL IReadoutWindow::GetUsePolarCoordinates()
{
	BOOL result;
	GetProperty(0x15, VT_BOOL, (void*)&result);
	return result;
}

void IReadoutWindow::SetUsePolarCoordinates(BOOL propVal)
{
	SetProperty(0x15, VT_BOOL, propVal);
}

BOOL IReadoutWindow::GetShowDistanceToTarget()
{
	BOOL result;
	GetProperty(0x16, VT_BOOL, (void*)&result);
	return result;
}

void IReadoutWindow::SetShowDistanceToTarget(BOOL propVal)
{
	SetProperty(0x16, VT_BOOL, propVal);
}

BOOL IReadoutWindow::GetShowDistanceToTargetWithAutoZoom()
{
	BOOL result;
	GetProperty(0x17, VT_BOOL, (void*)&result);
	return result;
}

void IReadoutWindow::SetShowDistanceToTargetWithAutoZoom(BOOL propVal)
{
	SetProperty(0x17, VT_BOOL, propVal);
}

BOOL IReadoutWindow::GetShowDistanceToTargetToExecutingFeature()
{
	BOOL result;
	GetProperty(0x18, VT_BOOL, (void*)&result);
	return result;
}

void IReadoutWindow::SetShowDistanceToTargetToExecutingFeature(BOOL propVal)
{
	SetProperty(0x18, VT_BOOL, propVal);
}

BOOL IReadoutWindow::GetShowDistanceToTargetToClosestFeature()
{
	BOOL result;
	GetProperty(0x19, VT_BOOL, (void*)&result);
	return result;
}

void IReadoutWindow::SetShowDistanceToTargetToClosestFeature(BOOL propVal)
{
	SetProperty(0x19, VT_BOOL, propVal);
}

BOOL IReadoutWindow::GetShowTargetToSurfaceEdge()
{
	BOOL result;
	GetProperty(0x1a, VT_BOOL, (void*)&result);
	return result;
}

void IReadoutWindow::SetShowTargetToSurfaceEdge(BOOL propVal)
{
	SetProperty(0x1a, VT_BOOL, propVal);
}

BOOL IReadoutWindow::GetShowTargetToCentroid()
{
	BOOL result;
	GetProperty(0x1b, VT_BOOL, (void*)&result);
	return result;
}

void IReadoutWindow::SetShowTargetToCentroid(BOOL propVal)
{
	SetProperty(0x1b, VT_BOOL, propVal);
}

BOOL IReadoutWindow::GetDisplayDistanceToClosestCAD()
{
	BOOL result;
	GetProperty(0x1c, VT_BOOL, (void*)&result);
	return result;
}

void IReadoutWindow::SetDisplayDistanceToClosestCAD(BOOL propVal)
{
	SetProperty(0x1c, VT_BOOL, propVal);
}

BOOL IReadoutWindow::GetApplyDimensionColor()
{
	BOOL result;
	GetProperty(0x1d, VT_BOOL, (void*)&result);
	return result;
}

void IReadoutWindow::SetApplyDimensionColor(BOOL propVal)
{
	SetProperty(0x1d, VT_BOOL, propVal);
}

long IReadoutWindow::GetDisplayPromptHistory()
{
	long result;
	GetProperty(0x1e, VT_I4, (void*)&result);
	return result;
}

void IReadoutWindow::SetDisplayPromptHistory(long propVal)
{
	SetProperty(0x1e, VT_I4, propVal);
}

BOOL IReadoutWindow::GetTrackerShowRMS()
{
	BOOL result;
	GetProperty(0x1f, VT_BOOL, (void*)&result);
	return result;
}

void IReadoutWindow::SetTrackerShowRMS(BOOL propVal)
{
	SetProperty(0x1f, VT_BOOL, propVal);
}

BOOL IReadoutWindow::GetTrackerBuildMode()
{
	BOOL result;
	GetProperty(0x20, VT_BOOL, (void*)&result);
	return result;
}

void IReadoutWindow::SetTrackerBuildMode(BOOL propVal)
{
	SetProperty(0x20, VT_BOOL, propVal);
}

BOOL IReadoutWindow::GetTrackerInspectMode()
{
	BOOL result;
	GetProperty(0x21, VT_BOOL, (void*)&result);
	return result;
}

void IReadoutWindow::SetTrackerInspectMode(BOOL propVal)
{
	SetProperty(0x21, VT_BOOL, propVal);
}

LPDISPATCH IReadoutWindow::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x22, VT_DISPATCH, (void*)&result);
	return result;
}

void IReadoutWindow::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x22, VT_DISPATCH, propVal);
}

BOOL IReadoutWindow::GetAvailable()
{
	BOOL result;
	GetProperty(0x23, VT_BOOL, (void*)&result);
	return result;
}

void IReadoutWindow::SetAvailable(BOOL propVal)
{
	SetProperty(0x23, VT_BOOL, propVal);
}

long IReadoutWindow::GetHitCount()
{
	long result;
	GetProperty(0x24, VT_I4, (void*)&result);
	return result;
}

void IReadoutWindow::SetHitCount(long propVal)
{
	SetProperty(0x24, VT_I4, propVal);
}

BOOL IReadoutWindow::Get_Visible()
{
	BOOL result;
	GetProperty(0x0, VT_BOOL, (void*)&result);
	return result;
}

void IReadoutWindow::Set_Visible(BOOL propVal)
{
	SetProperty(0x0, VT_BOOL, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IReadoutWindow operations

double IReadoutWindow::GetAAngle(long ArmNumber)
{
	double result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x25, DISPATCH_METHOD, VT_R8, (void*)&result, parms,
		ArmNumber);
	return result;
}

double IReadoutWindow::GetBAngle(long ArmNumber)
{
	double result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x26, DISPATCH_METHOD, VT_R8, (void*)&result, parms,
		ArmNumber);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IApplicationObjectEvents properties

/////////////////////////////////////////////////////////////////////////////
// IApplicationObjectEvents operations


/////////////////////////////////////////////////////////////////////////////
// IApplicationSettings properties

long IApplicationSettings::GetWarnOkMovPh9()
{
	long result;
	GetProperty(0x1, VT_I4, (void*)&result);
	return result;
}

void IApplicationSettings::SetWarnOkMovPh9(long propVal)
{
	SetProperty(0x1, VT_I4, propVal);
}

long IApplicationSettings::GetWarnOkRotPh9()
{
	long result;
	GetProperty(0x2, VT_I4, (void*)&result);
	return result;
}

void IApplicationSettings::SetWarnOkRotPh9(long propVal)
{
	SetProperty(0x2, VT_I4, propVal);
}

long IApplicationSettings::GetWarningDefaultOkRotPh9()
{
	long result;
	GetProperty(0x3, VT_I4, (void*)&result);
	return result;
}

void IApplicationSettings::SetWarningDefaultOkRotPh9(long propVal)
{
	SetProperty(0x3, VT_I4, propVal);
}

long IApplicationSettings::GetWarnNoSavePrg()
{
	long result;
	GetProperty(0x4, VT_I4, (void*)&result);
	return result;
}

void IApplicationSettings::SetWarnNoSavePrg(long propVal)
{
	SetProperty(0x4, VT_I4, propVal);
}

long IApplicationSettings::GetWarnOverwritingAlignment()
{
	long result;
	GetProperty(0x5, VT_I4, (void*)&result);
	return result;
}

void IApplicationSettings::SetWarnOverwritingAlignment(long propVal)
{
	SetProperty(0x5, VT_I4, propVal);
}

long IApplicationSettings::GetWarningDefaultNoSavePrg()
{
	long result;
	GetProperty(0x6, VT_I4, (void*)&result);
	return result;
}

void IApplicationSettings::SetWarningDefaultNoSavePrg(long propVal)
{
	SetProperty(0x6, VT_I4, propVal);
}

long IApplicationSettings::GetWarningDefaultOverwritingAlignment()
{
	long result;
	GetProperty(0x7, VT_I4, (void*)&result);
	return result;
}

void IApplicationSettings::SetWarningDefaultOverwritingAlignment(long propVal)
{
	SetProperty(0x7, VT_I4, propVal);
}

long IApplicationSettings::GetWarnOKUsePh9()
{
	long result;
	GetProperty(0x8, VT_I4, (void*)&result);
	return result;
}

void IApplicationSettings::SetWarnOKUsePh9(long propVal)
{
	SetProperty(0x8, VT_I4, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IApplicationSettings operations


/////////////////////////////////////////////////////////////////////////////
// ILabelTemplates properties

LPDISPATCH ILabelTemplates::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x1, VT_DISPATCH, (void*)&result);
	return result;
}

void ILabelTemplates::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x1, VT_DISPATCH, propVal);
}

LPDISPATCH ILabelTemplates::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x2, VT_DISPATCH, (void*)&result);
	return result;
}

void ILabelTemplates::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x2, VT_DISPATCH, propVal);
}

long ILabelTemplates::GetCount()
{
	long result;
	GetProperty(0x3, VT_I4, (void*)&result);
	return result;
}

void ILabelTemplates::SetCount(long propVal)
{
	SetProperty(0x3, VT_I4, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// ILabelTemplates operations

LPDISPATCH ILabelTemplates::Open(LPCTSTR filename)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		filename);
	return result;
}

LPDISPATCH ILabelTemplates::Add()
{
	LPDISPATCH result;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH ILabelTemplates::Item(const VARIANT& NameOrNumber)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&NameOrNumber);
	return result;
}

LPDISPATCH ILabelTemplates::_Item(const VARIANT& NameOrNumber)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&NameOrNumber);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ILabelTemplate properties

BOOL ILabelTemplate::GetVisible()
{
	BOOL result;
	GetProperty(0x1, VT_BOOL, (void*)&result);
	return result;
}

void ILabelTemplate::SetVisible(BOOL propVal)
{
	SetProperty(0x1, VT_BOOL, propVal);
}

LPDISPATCH ILabelTemplate::GetLabelControls()
{
	LPDISPATCH result;
	GetProperty(0x2, VT_DISPATCH, (void*)&result);
	return result;
}

void ILabelTemplate::SetLabelControls(LPDISPATCH propVal)
{
	SetProperty(0x2, VT_DISPATCH, propVal);
}

LPDISPATCH ILabelTemplate::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x3, VT_DISPATCH, (void*)&result);
	return result;
}

void ILabelTemplate::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x3, VT_DISPATCH, propVal);
}

LPDISPATCH ILabelTemplate::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x4, VT_DISPATCH, (void*)&result);
	return result;
}

void ILabelTemplate::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x4, VT_DISPATCH, propVal);
}

CString ILabelTemplate::GetName()
{
	CString result;
	GetProperty(0x5, VT_BSTR, (void*)&result);
	return result;
}

void ILabelTemplate::SetName(LPCTSTR propVal)
{
	SetProperty(0x5, VT_BSTR, propVal);
}

CString ILabelTemplate::GetFullName()
{
	CString result;
	GetProperty(0x6, VT_BSTR, (void*)&result);
	return result;
}

void ILabelTemplate::SetFullName(LPCTSTR propVal)
{
	SetProperty(0x6, VT_BSTR, propVal);
}

CString ILabelTemplate::Get_Name()
{
	CString result;
	GetProperty(0x0, VT_BSTR, (void*)&result);
	return result;
}

void ILabelTemplate::Set_Name(LPCTSTR propVal)
{
	SetProperty(0x0, VT_BSTR, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// ILabelTemplate operations

BOOL ILabelTemplate::Save()
{
	BOOL result;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
	return result;
}

BOOL ILabelTemplate::SaveAs(LPCTSTR filename)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x8, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		filename);
	return result;
}

void ILabelTemplate::Close()
{
	InvokeHelper(0x9, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// ILabelControls properties

LPDISPATCH ILabelControls::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x2, VT_DISPATCH, (void*)&result);
	return result;
}

void ILabelControls::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x2, VT_DISPATCH, propVal);
}

LPDISPATCH ILabelControls::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x3, VT_DISPATCH, (void*)&result);
	return result;
}

void ILabelControls::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x3, VT_DISPATCH, propVal);
}

long ILabelControls::GetCount()
{
	long result;
	GetProperty(0x4, VT_I4, (void*)&result);
	return result;
}

void ILabelControls::SetCount(long propVal)
{
	SetProperty(0x4, VT_I4, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// ILabelControls operations

LPDISPATCH ILabelControls::Item(const VARIANT& NameOrNumber)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x1, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&NameOrNumber);
	return result;
}

LPDISPATCH ILabelControls::Add(long ObjectType, long Left, long Top, long Right, long Bottom)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		ObjectType, Left, Top, Right, Bottom);
	return result;
}

long ILabelControls::Remove(const VARIANT& NameOrNumber)
{
	long result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		&NameOrNumber);
	return result;
}

LPDISPATCH ILabelControls::_Item(const VARIANT& NameOrNumber)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&NameOrNumber);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IPortLock properties

long IPortLock::GetLockID()
{
	long result;
	GetProperty(0x1, VT_I4, (void*)&result);
	return result;
}

void IPortLock::SetLockID(long propVal)
{
	SetProperty(0x1, VT_I4, propVal);
}

LPDISPATCH IPortLock::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x2, VT_DISPATCH, (void*)&result);
	return result;
}

void IPortLock::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x2, VT_DISPATCH, propVal);
}

long IPortLock::Get_id()
{
	long result;
	GetProperty(0x0, VT_I4, (void*)&result);
	return result;
}

void IPortLock::Set_id(long propVal)
{
	SetProperty(0x0, VT_I4, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IPortLock operations


/////////////////////////////////////////////////////////////////////////////
// INotificationSettings properties

BOOL INotificationSettings::GetNotificationON()
{
	BOOL result;
	GetProperty(0x1, VT_BOOL, (void*)&result);
	return result;
}

void INotificationSettings::SetNotificationON(BOOL propVal)
{
	SetProperty(0x1, VT_BOOL, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// INotificationSettings operations

void INotificationSettings::ResetDevice()
{
	InvokeHelper(0x2, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// IRegistrySettings properties

LPDISPATCH IRegistrySettings::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x1, VT_DISPATCH, (void*)&result);
	return result;
}

void IRegistrySettings::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x1, VT_DISPATCH, propVal);
}

LPDISPATCH IRegistrySettings::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x2, VT_DISPATCH, (void*)&result);
	return result;
}

void IRegistrySettings::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x2, VT_DISPATCH, propVal);
}

long IRegistrySettings::GetCount()
{
	long result;
	GetProperty(0x3, VT_I4, (void*)&result);
	return result;
}

void IRegistrySettings::SetCount(long propVal)
{
	SetProperty(0x3, VT_I4, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IRegistrySettings operations

LPDISPATCH IRegistrySettings::Item(const VARIANT& Identifier)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&Identifier);
	return result;
}

LPDISPATCH IRegistrySettings::First()
{
	LPDISPATCH result;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH IRegistrySettings::Next(LPDISPATCH Identifier)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Identifier);
	return result;
}

void IRegistrySettings::RemoveAll()
{
	InvokeHelper(0x8, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// IRegistrySetting properties

CString IRegistrySetting::GetKeyName()
{
	CString result;
	GetProperty(0x1, VT_BSTR, (void*)&result);
	return result;
}

void IRegistrySetting::SetKeyName(LPCTSTR propVal)
{
	SetProperty(0x1, VT_BSTR, propVal);
}

CString IRegistrySetting::GetValueName()
{
	CString result;
	GetProperty(0x2, VT_BSTR, (void*)&result);
	return result;
}

void IRegistrySetting::SetValueName(LPCTSTR propVal)
{
	SetProperty(0x2, VT_BSTR, propVal);
}

CString IRegistrySetting::GetValue()
{
	CString result;
	GetProperty(0x3, VT_BSTR, (void*)&result);
	return result;
}

void IRegistrySetting::SetValue(LPCTSTR propVal)
{
	SetProperty(0x3, VT_BSTR, propVal);
}

long IRegistrySetting::GetType()
{
	long result;
	GetProperty(0x4, VT_I4, (void*)&result);
	return result;
}

void IRegistrySetting::SetType(long propVal)
{
	SetProperty(0x4, VT_I4, propVal);
}

BOOL IRegistrySetting::GetUsed()
{
	BOOL result;
	GetProperty(0x5, VT_BOOL, (void*)&result);
	return result;
}

void IRegistrySetting::SetUsed(BOOL propVal)
{
	SetProperty(0x5, VT_BOOL, propVal);
}

long IRegistrySetting::GetAccessLevel()
{
	long result;
	GetProperty(0x7, VT_I4, (void*)&result);
	return result;
}

void IRegistrySetting::SetAccessLevel(long propVal)
{
	SetProperty(0x7, VT_I4, propVal);
}

long IRegistrySetting::GetGroup()
{
	long result;
	GetProperty(0x8, VT_I4, (void*)&result);
	return result;
}

void IRegistrySetting::SetGroup(long propVal)
{
	SetProperty(0x8, VT_I4, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IRegistrySetting operations

void IRegistrySetting::DeleteKey()
{
	InvokeHelper(0x6, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL IRegistrySetting::IsWriteable()
{
	BOOL result;
	InvokeHelper(0x9, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IPartProgramEvents properties

/////////////////////////////////////////////////////////////////////////////
// IPartProgramEvents operations

void IPartProgramEvents::OnObjectAboutToExecute(LPDISPATCH Command)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x1, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Command);
}

void IPartProgramEvents::OnObjectExecuted(LPDISPATCH Command)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x2, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Command);
}

void IPartProgramEvents::OnStartExecution()
{
	InvokeHelper(0x3, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IPartProgramEvents::OnEndExecution(long TerminationType)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x4, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 TerminationType);
}

void IPartProgramEvents::OnAddObject(LPDISPATCH Command)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Command);
}

void IPartProgramEvents::OnExecuteDialogErrorMsg(LPCTSTR ErrorMsg)
{
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 ErrorMsg);
}

void IPartProgramEvents::OnExecuteDialogStatusMsg(LPCTSTR StatusMsg)
{
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 StatusMsg);
}

void IPartProgramEvents::OnObjectAboutToExecute2(LPDISPATCH Command, long Arm)
{
	static BYTE parms[] =
		VTS_DISPATCH VTS_I4;
	InvokeHelper(0x8, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Command, Arm);
}

void IPartProgramEvents::OnObjectExecuted2(LPDISPATCH Command, long Arm)
{
	static BYTE parms[] =
		VTS_DISPATCH VTS_I4;
	InvokeHelper(0x9, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Command, Arm);
}

void IPartProgramEvents::OnWorkOffset(double dX, double dY, double dZ, double rx, double ry, double rz, LPCTSTR file, LPCTSTR progname, LPCTSTR gcode)
{
	static BYTE parms[] =
		VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_BSTR VTS_BSTR VTS_BSTR;
	InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 dX, dY, dZ, rx, ry, rz, file, progname, gcode);
}

void IPartProgramEvents::OnToolOffset(double dd, double dl, LPCTSTR file, LPCTSTR progname, LPCTSTR toolNumber)
{
	static BYTE parms[] =
		VTS_R8 VTS_R8 VTS_BSTR VTS_BSTR VTS_BSTR;
	InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 dd, dl, file, progname, toolNumber);
}

void IPartProgramEvents::OnWriteCncVar(long index, double val)
{
	static BYTE parms[] =
		VTS_I4 VTS_R8;
	InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 index, val);
}

void IPartProgramEvents::OnReadCncVar(long index, double* pval)
{
	static BYTE parms[] =
		VTS_I4 VTS_PR8;
	InvokeHelper(0xd, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 index, pval);
}

void IPartProgramEvents::OnGuess(LPDISPATCH Command, long Arm)
{
	static BYTE parms[] =
		VTS_DISPATCH VTS_I4;
	InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Command, Arm);
}


/////////////////////////////////////////////////////////////////////////////
// IMachineEvents properties

/////////////////////////////////////////////////////////////////////////////
// IMachineEvents operations

void IMachineEvents::LearnHit(double X, double Y, double Z, double I, double J, double K)
{
	static BYTE parms[] =
		VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0x1, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 X, Y, Z, I, J, K);
}

void IMachineEvents::ExecuteHit(double X, double Y, double Z, double I, double J, double K)
{
	static BYTE parms[] =
		VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0x2, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 X, Y, Z, I, J, K);
}

void IMachineEvents::ErrorMsg(LPCTSTR Msg, long ErrorType)
{
	static BYTE parms[] =
		VTS_BSTR VTS_I4;
	InvokeHelper(0x3, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Msg, ErrorType);
}

void IMachineEvents::Command(long Code)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x4, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Code);
}

void IMachineEvents::Readout(double X, double Y, double Z, double I, double J, double K)
{
	static BYTE parms[] =
		VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 X, Y, Z, I, J, K);
}

void IMachineEvents::ExecuteManualScanHit(double X, double Y, double Z, double I, double J, double K)
{
	static BYTE parms[] =
		VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 X, Y, Z, I, J, K);
}

void IMachineEvents::FeatureID(LPCTSTR fid)
{
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 fid);
}

void IMachineEvents::FeatureType(LPCTSTR ftype)
{
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x8, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 ftype);
}

void IMachineEvents::RMS(double RMS)
{
	static BYTE parms[] =
		VTS_R8;
	InvokeHelper(0x9, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 RMS);
}

void IMachineEvents::DistanceToTarget(double dX, double dY, double dZ, double T, double tol)
{
	static BYTE parms[] =
		VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 dX, dY, dZ, T, tol);
}

void IMachineEvents::DistanceToClosestCAD(double dX, double dY, double dZ, double T, double tol)
{
	static BYTE parms[] =
		VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 dX, dY, dZ, T, tol);
}

void IMachineEvents::ReadoutExt(double X, double Y, double Z)
{
	static BYTE parms[] =
		VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 X, Y, Z);
}


/////////////////////////////////////////////////////////////////////////////
// IAutotrigger properties

long IAutotrigger::GetAutotriggeron()
{
	long result;
	GetProperty(0x1, VT_I4, (void*)&result);
	return result;
}

void IAutotrigger::SetAutotriggeron(long propVal)
{
	SetProperty(0x1, VT_I4, propVal);
}

long IAutotrigger::GetBeepingon()
{
	long result;
	GetProperty(0x2, VT_I4, (void*)&result);
	return result;
}

void IAutotrigger::SetBeepingon(long propVal)
{
	SetProperty(0x2, VT_I4, propVal);
}

double IAutotrigger::GetRadius()
{
	double result;
	GetProperty(0x3, VT_R8, (void*)&result);
	return result;
}

void IAutotrigger::SetRadius(double propVal)
{
	SetProperty(0x3, VT_R8, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IAutotrigger operations


/////////////////////////////////////////////////////////////////////////////
// IApplicationEvents properties

/////////////////////////////////////////////////////////////////////////////
// IApplicationEvents operations

void IApplicationEvents::OnObjectAboutToExecute(LPDISPATCH PartProg, LPDISPATCH Cmmd)
{
	static BYTE parms[] =
		VTS_DISPATCH VTS_DISPATCH;
	InvokeHelper(0x1, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 PartProg, Cmmd);
}

void IApplicationEvents::OnObjectExecuted(LPDISPATCH PartProg, LPDISPATCH Cmmd)
{
	static BYTE parms[] =
		VTS_DISPATCH VTS_DISPATCH;
	InvokeHelper(0x2, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 PartProg, Cmmd);
}

void IApplicationEvents::OnStartExecution(LPDISPATCH PartProg)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x3, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 PartProg);
}

void IApplicationEvents::OnEndExecution(LPDISPATCH PartProg, long TerminationType)
{
	static BYTE parms[] =
		VTS_DISPATCH VTS_I4;
	InvokeHelper(0x4, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 PartProg, TerminationType);
}

void IApplicationEvents::OnAddObject(LPDISPATCH PartProg, LPDISPATCH Command)
{
	static BYTE parms[] =
		VTS_DISPATCH VTS_DISPATCH;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 PartProg, Command);
}

void IApplicationEvents::OnOpenPartProgram(LPDISPATCH PartProg)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 PartProg);
}

void IApplicationEvents::OnClosePartProgram(LPDISPATCH PartProg)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 PartProg);
}

void IApplicationEvents::OnSavePartProgram(LPDISPATCH PartProg)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x8, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 PartProg);
}

void IApplicationEvents::OnUpdateStatusMessage(LPCTSTR Msg)
{
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x9, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Msg);
}

void IApplicationEvents::OnOpenRemotePanelDialog(LPDISPATCH PartProg, long DialogId, long hWnd, LPCTSTR Message, long BtnId1, long BtnId2, long BtnId3, long BtnId4, long DefaultBtn)
{
	static BYTE parms[] =
		VTS_DISPATCH VTS_I4 VTS_I4 VTS_BSTR VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4;
	InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 PartProg, DialogId, hWnd, Message, BtnId1, BtnId2, BtnId3, BtnId4, DefaultBtn);
}

void IApplicationEvents::OnConnectSlave(LPDISPATCH PartProg)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 PartProg);
}

void IApplicationEvents::OnDisconnectSlave(LPDISPATCH PartProg)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 PartProg);
}

void IApplicationEvents::OnObjectAboutToExecute2(LPDISPATCH PartProg, LPDISPATCH Cmmd, long Arm)
{
	static BYTE parms[] =
		VTS_DISPATCH VTS_DISPATCH VTS_I4;
	InvokeHelper(0xd, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 PartProg, Cmmd, Arm);
}

void IApplicationEvents::OnObjectExecuted2(LPDISPATCH PartProg, LPDISPATCH Cmmd, long Arm)
{
	static BYTE parms[] =
		VTS_DISPATCH VTS_DISPATCH VTS_I4;
	InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 PartProg, Cmmd, Arm);
}

void IApplicationEvents::OnOpenRemotePanelDialog2(LPDISPATCH PartProg, long DialogId, long hWnd, LPCTSTR Message, long BtnId1, long BtnId2, long BtnId3, long BtnId4, long BtnId5, long DefaultBtn)
{
	static BYTE parms[] =
		VTS_DISPATCH VTS_I4 VTS_I4 VTS_BSTR VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4;
	InvokeHelper(0xf, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 PartProg, DialogId, hWnd, Message, BtnId1, BtnId2, BtnId3, BtnId4, BtnId5, DefaultBtn);
}

void IApplicationEvents::OnCloseRemotePanelDialog(LPDISPATCH PartProg, long DialogId, long hClosedWnd, LPCTSTR Message, long PushedBtnID)
{
	static BYTE parms[] =
		VTS_DISPATCH VTS_I4 VTS_I4 VTS_BSTR VTS_I4;
	InvokeHelper(0x10, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 PartProg, DialogId, hClosedWnd, Message, PushedBtnID);
}

void IApplicationEvents::OnPCDMessageBoxOpen(LPDISPATCH PCDMessageBox)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x11, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 PCDMessageBox);
}

void IApplicationEvents::OnPCDMessageBoxClose(LPDISPATCH PCDMessageBox, long PushedBtnID)
{
	static BYTE parms[] =
		VTS_DISPATCH VTS_I4;
	InvokeHelper(0x12, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 PCDMessageBox, PushedBtnID);
}

void IApplicationEvents::OnOpenExecutionDialog(LPDISPATCH ExecutionWindow)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x13, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 ExecutionWindow);
}

void IApplicationEvents::OnCloseExecutionDialog(LPDISPATCH ExecutionWindow)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x14, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 ExecutionWindow);
}

void IApplicationEvents::OnCommentInputDialogOpen(LPDISPATCH CommentInputDialog)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x15, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 CommentInputDialog);
}

void IApplicationEvents::OnCommentInputDialogClose(LPDISPATCH CommentInputDialog, long PushedBtnID)
{
	static BYTE parms[] =
		VTS_DISPATCH VTS_I4;
	InvokeHelper(0x16, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 CommentInputDialog, PushedBtnID);
}

void IApplicationEvents::OnExecutionDialogButton(LPDISPATCH ExecutionWindow, long PushedBtnID)
{
	static BYTE parms[] =
		VTS_DISPATCH VTS_I4;
	InvokeHelper(0x17, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 ExecutionWindow, PushedBtnID);
}


/////////////////////////////////////////////////////////////////////////////
// IPCDMessageBox properties

LPDISPATCH IPCDMessageBox::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x1, VT_DISPATCH, (void*)&result);
	return result;
}

void IPCDMessageBox::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x1, VT_DISPATCH, propVal);
}

BOOL IPCDMessageBox::GetIsClosed()
{
	BOOL result;
	GetProperty(0x4, VT_BOOL, (void*)&result);
	return result;
}

void IPCDMessageBox::SetIsClosed(BOOL propVal)
{
	SetProperty(0x4, VT_BOOL, propVal);
}

CString IPCDMessageBox::GetCaption()
{
	CString result;
	GetProperty(0x5, VT_BSTR, (void*)&result);
	return result;
}

void IPCDMessageBox::SetCaption(LPCTSTR propVal)
{
	SetProperty(0x5, VT_BSTR, propVal);
}

CString IPCDMessageBox::GetMessage()
{
	CString result;
	GetProperty(0x6, VT_BSTR, (void*)&result);
	return result;
}

void IPCDMessageBox::SetMessage(LPCTSTR propVal)
{
	SetProperty(0x6, VT_BSTR, propVal);
}

LPDISPATCH IPCDMessageBox::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x7, VT_DISPATCH, (void*)&result);
	return result;
}

void IPCDMessageBox::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x7, VT_DISPATCH, propVal);
}

BOOL IPCDMessageBox::GetHasShutDownButton()
{
	BOOL result;
	GetProperty(0x8, VT_BOOL, (void*)&result);
	return result;
}

void IPCDMessageBox::SetHasShutDownButton(BOOL propVal)
{
	SetProperty(0x8, VT_BOOL, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IPCDMessageBox operations

BOOL IPCDMessageBox::HasButton(long ButtonType)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x2, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		ButtonType);
	return result;
}

long IPCDMessageBox::PressButton(long ButtonType)
{
	long result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x3, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		ButtonType);
	return result;
}

long IPCDMessageBox::PressShutDownButton()
{
	long result;
	InvokeHelper(0x9, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ICommentInputDialog properties

LPDISPATCH ICommentInputDialog::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x1, VT_DISPATCH, (void*)&result);
	return result;
}

void ICommentInputDialog::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x1, VT_DISPATCH, propVal);
}

BOOL ICommentInputDialog::GetIsClosed()
{
	BOOL result;
	GetProperty(0x4, VT_BOOL, (void*)&result);
	return result;
}

void ICommentInputDialog::SetIsClosed(BOOL propVal)
{
	SetProperty(0x4, VT_BOOL, propVal);
}

CString ICommentInputDialog::GetCaption()
{
	CString result;
	GetProperty(0x5, VT_BSTR, (void*)&result);
	return result;
}

void ICommentInputDialog::SetCaption(LPCTSTR propVal)
{
	SetProperty(0x5, VT_BSTR, propVal);
}

CString ICommentInputDialog::GetMessage()
{
	CString result;
	GetProperty(0x6, VT_BSTR, (void*)&result);
	return result;
}

void ICommentInputDialog::SetMessage(LPCTSTR propVal)
{
	SetProperty(0x6, VT_BSTR, propVal);
}

LPDISPATCH ICommentInputDialog::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x7, VT_DISPATCH, (void*)&result);
	return result;
}

void ICommentInputDialog::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x7, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// ICommentInputDialog operations

long ICommentInputDialog::PressOKButton()
{
	long result;
	InvokeHelper(0x2, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
	return result;
}

long ICommentInputDialog::PressCancelButton()
{
	long result;
	InvokeHelper(0x3, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
	return result;
}

long ICommentInputDialog::SetInputText(LPCTSTR InputText)
{
	long result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x8, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		InputText);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// Itutorhit properties

/////////////////////////////////////////////////////////////////////////////
// Itutorhit operations


/////////////////////////////////////////////////////////////////////////////
// IAnalysisWindow properties

LPDISPATCH IAnalysisWindow::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x1, VT_DISPATCH, (void*)&result);
	return result;
}

void IAnalysisWindow::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x1, VT_DISPATCH, propVal);
}

LPDISPATCH IAnalysisWindow::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x2, VT_DISPATCH, (void*)&result);
	return result;
}

void IAnalysisWindow::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x2, VT_DISPATCH, propVal);
}

long IAnalysisWindow::GetTransparent()
{
	long result;
	GetProperty(0x3, VT_I4, (void*)&result);
	return result;
}

void IAnalysisWindow::SetTransparent(long propVal)
{
	SetProperty(0x3, VT_I4, propVal);
}

double IAnalysisWindow::GetMaxMinSize()
{
	double result;
	GetProperty(0x4, VT_R8, (void*)&result);
	return result;
}

void IAnalysisWindow::SetMaxMinSize(double propVal)
{
	SetProperty(0x4, VT_R8, propVal);
}

long IAnalysisWindow::GetMaxColor()
{
	long result;
	GetProperty(0x5, VT_I4, (void*)&result);
	return result;
}

void IAnalysisWindow::SetMaxColor(long propVal)
{
	SetProperty(0x5, VT_I4, propVal);
}

long IAnalysisWindow::GetMinColor()
{
	long result;
	GetProperty(0x6, VT_I4, (void*)&result);
	return result;
}

void IAnalysisWindow::SetMinColor(long propVal)
{
	SetProperty(0x6, VT_I4, propVal);
}

long IAnalysisWindow::GetTrihedron()
{
	long result;
	GetProperty(0x7, VT_I4, (void*)&result);
	return result;
}

void IAnalysisWindow::SetTrihedron(long propVal)
{
	SetProperty(0x7, VT_I4, propVal);
}

long IAnalysisWindow::GetTitle()
{
	long result;
	GetProperty(0x8, VT_I4, (void*)&result);
	return result;
}

void IAnalysisWindow::SetTitle(long propVal)
{
	SetProperty(0x8, VT_I4, propVal);
}

long IAnalysisWindow::GetDeviations()
{
	long result;
	GetProperty(0x9, VT_I4, (void*)&result);
	return result;
}

void IAnalysisWindow::SetDeviations(long propVal)
{
	SetProperty(0x9, VT_I4, propVal);
}

long IAnalysisWindow::GetBorder()
{
	long result;
	GetProperty(0xa, VT_I4, (void*)&result);
	return result;
}

void IAnalysisWindow::SetBorder(long propVal)
{
	SetProperty(0xa, VT_I4, propVal);
}

long IAnalysisWindow::GetLabelOffset()
{
	long result;
	GetProperty(0xc, VT_I4, (void*)&result);
	return result;
}

void IAnalysisWindow::SetLabelOffset(long propVal)
{
	SetProperty(0xc, VT_I4, propVal);
}

LPDISPATCH IAnalysisWindow::GetHOBPointInfoList()
{
	LPDISPATCH result;
	GetProperty(0xd, VT_DISPATCH, (void*)&result);
	return result;
}

void IAnalysisWindow::SetHOBPointInfoList(LPDISPATCH propVal)
{
	SetProperty(0xd, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IAnalysisWindow operations

void IAnalysisWindow::RepaintCustomReport(long i_bNeedUpdate)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 i_bNeedUpdate);
}


/////////////////////////////////////////////////////////////////////////////
// IHOBPointInfoList properties

LPDISPATCH IHOBPointInfoList::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x1, VT_DISPATCH, (void*)&result);
	return result;
}

void IHOBPointInfoList::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x1, VT_DISPATCH, propVal);
}

LPDISPATCH IHOBPointInfoList::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x2, VT_DISPATCH, (void*)&result);
	return result;
}

void IHOBPointInfoList::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x2, VT_DISPATCH, propVal);
}

long IHOBPointInfoList::GetCount()
{
	long result;
	GetProperty(0x3, VT_I4, (void*)&result);
	return result;
}

void IHOBPointInfoList::SetCount(long propVal)
{
	SetProperty(0x3, VT_I4, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IHOBPointInfoList operations

LPDISPATCH IHOBPointInfoList::Item(long i_nIndex)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		i_nIndex);
	return result;
}

CString IHOBPointInfoList::ID(long i_nIndex)
{
	CString result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
		i_nIndex);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IHOBPointInfo properties

LPDISPATCH IHOBPointInfo::GetApplication()
{
	LPDISPATCH result;
	GetProperty(0x1, VT_DISPATCH, (void*)&result);
	return result;
}

void IHOBPointInfo::SetApplication(LPDISPATCH propVal)
{
	SetProperty(0x1, VT_DISPATCH, propVal);
}

LPDISPATCH IHOBPointInfo::GetParent()
{
	LPDISPATCH result;
	GetProperty(0x2, VT_DISPATCH, (void*)&result);
	return result;
}

void IHOBPointInfo::SetParent(LPDISPATCH propVal)
{
	SetProperty(0x2, VT_DISPATCH, propVal);
}

long IHOBPointInfo::GetCount()
{
	long result;
	GetProperty(0x3, VT_I4, (void*)&result);
	return result;
}

void IHOBPointInfo::SetCount(long propVal)
{
	SetProperty(0x3, VT_I4, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IHOBPointInfo operations

long IHOBPointInfo::IsVisible(long i_nIndex)
{
	long result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x4, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		i_nIndex);
	return result;
}

long IHOBPointInfo::GetHideLeader(long i_nIndex)
{
	long result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		i_nIndex);
	return result;
}

long IHOBPointInfo::SetHideLeader(long i_nIndex, long i_bNewValue)
{
	long result;
	static BYTE parms[] =
		VTS_I4 VTS_I4;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		i_nIndex, i_bNewValue);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// IPicture properties

/////////////////////////////////////////////////////////////////////////////
// IPicture operations

long IPicture::GetBitmapDataSize()
{
	long result;
	InvokeHelper(0x1, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
	return result;
}

void IPicture::GetBitmapData(VARIANT* buffer)
{
	static BYTE parms[] =
		VTS_PVARIANT;
	InvokeHelper(0x2, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 buffer);
}


/////////////////////////////////////////////////////////////////////////////
// IReportData properties

long IReportData::GetCurPage()
{
	long result;
	GetProperty(0xd, VT_I4, (void*)&result);
	return result;
}

void IReportData::SetCurPage(long propVal)
{
	SetProperty(0xd, VT_I4, propVal);
}

CString IReportData::GetToolkitICommandInstanceGuid()
{
	CString result;
	GetProperty(0xf, VT_BSTR, (void*)&result);
	return result;
}

void IReportData::SetToolkitICommandInstanceGuid(LPCTSTR propVal)
{
	SetProperty(0xf, VT_BSTR, propVal);
}

CString IReportData::GetToolkitIPartProgramManagerInstanceGuid()
{
	CString result;
	GetProperty(0x10, VT_BSTR, (void*)&result);
	return result;
}

void IReportData::SetToolkitIPartProgramManagerInstanceGuid(LPCTSTR propVal)
{
	SetProperty(0x10, VT_BSTR, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IReportData operations

VARIANT IReportData::GetValue(long DataType, long TypeIndex)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_I4 VTS_I4;
	InvokeHelper(0x1, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		DataType, TypeIndex);
	return result;
}

VARIANT IReportData::GetValue2(long DataType, long TypeIndex, long FirstArrayIndex, long SecondArrayIndex)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_I4 VTS_I4;
	InvokeHelper(0x2, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		DataType, TypeIndex, FirstArrayIndex, SecondArrayIndex);
	return result;
}

BOOL IReportData::HasCommandData()
{
	BOOL result;
	InvokeHelper(0x3, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
	return result;
}

LPDISPATCH IReportData::GetCommand()
{
	LPDISPATCH result;
	InvokeHelper(0x4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

long IReportData::GetCount(long DataType)
{
	long result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		DataType);
	return result;
}

long IReportData::GetTolColor(double Deviation, double plustol, double minustol)
{
	long result;
	static BYTE parms[] =
		VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		Deviation, plustol, minustol);
	return result;
}

VARIANT IReportData::GetColorList()
{
	VARIANT result;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT IReportData::GetReferenceValue(long refValue, long DataType, long TypeIndex)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_I4;
	InvokeHelper(0xa, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		refValue, DataType, TypeIndex);
	return result;
}

VARIANT IReportData::GetReferenceValue2(long refValue, long DataType, long TypeIndex, long FirstArrayIndex, long SecondArrayIndex)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4;
	InvokeHelper(0xb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		refValue, DataType, TypeIndex, FirstArrayIndex, SecondArrayIndex);
	return result;
}

VARIANT IReportData::GetExpressionValue(LPCTSTR Expression)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0xc, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		Expression);
	return result;
}

BOOL IReportData::HasToolkitCommandData()
{
	BOOL result;
	InvokeHelper(0xe, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
	return result;
}

VARIANT IReportData::GetCommandData(LPCTSTR _expression, LPCTSTR _option)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR;
	InvokeHelper(0x11, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		_expression, _option);
	return result;
}

}